'no use strict';
!(function (window) {
  if (typeof window.window != 'undefined' && window.document) return;
  if (window.require && window.define) return;

  if (!window.console) {
    window.console = function () {
      var msgs = Array.prototype.slice.call(arguments, 0);
      postMessage({ type: 'log', data: msgs });
    };
    window.console.error = window.console.warn = window.console.log = window.console.trace = window.console;
  }
  window.window = window;
  window.ace = window;

  window.onerror = function (message, file, line, col, err) {
    postMessage({
      type: 'error',
      data: {
        message: message,
        data: err && err.data,
        file: file,
        line: line,
        col: col,
        stack: err && err.stack,
      },
    });
  };

  window.normalizeModule = function (parentId, moduleName) {
    // normalize plugin requires
    if (moduleName.indexOf('!') !== -1) {
      var chunks = moduleName.split('!');
      return window.normalizeModule(parentId, chunks[0]) + '!' + window.normalizeModule(parentId, chunks[1]);
    }
    // normalize relative requires
    if (moduleName.charAt(0) == '.') {
      var base = parentId.split('/').slice(0, -1).join('/');
      moduleName = (base ? base + '/' : '') + moduleName;

      while (moduleName.indexOf('.') !== -1 && previous != moduleName) {
        var previous = moduleName;
        moduleName = moduleName
          .replace(/^\.\//, '')
          .replace(/\/\.\//, '/')
          .replace(/[^\/]+\/\.\.\//, '');
      }
    }

    return moduleName;
  };

  window.require = function require(parentId, id) {
    if (!id) {
      id = parentId;
      parentId = null;
    }
    if (!id.charAt) throw new Error('worker.js require() accepts only (parentId, id) as arguments');

    id = window.normalizeModule(parentId, id);

    var module = window.require.modules[id];
    if (module) {
      if (!module.initialized) {
        module.initialized = true;
        module.exports = module.factory().exports;
      }
      return module.exports;
    }

    if (!window.require.tlns) return console.log('unable to load ' + id);

    var path = resolveModuleId(id, window.require.tlns);
    if (path.slice(-3) != '.js') path += '.js';

    window.require.id = id;
    window.require.modules[id] = {}; // prevent infinite loop on broken modules
    importScripts(path);
    return window.require(parentId, id);
  };
  function resolveModuleId(id, paths) {
    var testPath = id,
      tail = '';
    while (testPath) {
      var alias = paths[testPath];
      if (typeof alias == 'string') {
        return alias + tail;
      } else if (alias) {
        return alias.location.replace(/\/*$/, '/') + (tail || alias.main || alias.name);
      } else if (alias === false) {
        return '';
      }
      var i = testPath.lastIndexOf('/');
      if (i === -1) break;
      tail = testPath.substr(i) + tail;
      testPath = testPath.slice(0, i);
    }
    return id;
  }
  window.require.modules = {};
  window.require.tlns = {};

  window.define = function (id, deps, factory) {
    if (arguments.length == 2) {
      factory = deps;
      if (typeof id != 'string') {
        deps = id;
        id = window.require.id;
      }
    } else if (arguments.length == 1) {
      factory = id;
      deps = [];
      id = window.require.id;
    }

    if (typeof factory != 'function') {
      window.require.modules[id] = {
        exports: factory,
        initialized: true,
      };
      return;
    }

    if (!deps.length)
      // If there is no dependencies, we inject "require", "exports" and
      // "module" as dependencies, to provide CommonJS compatibility.
      deps = ['require', 'exports', 'module'];

    var req = function (childId) {
      return window.require(id, childId);
    };

    window.require.modules[id] = {
      exports: {},
      factory: function () {
        var module = this;
        var returnExports = factory.apply(
          this,
          deps.slice(0, factory.length).map(function (dep) {
            switch (dep) {
              // Because "require", "exports" and "module" aren't actual
              // dependencies, we must handle them seperately.
              case 'require':
                return req;
              case 'exports':
                return module.exports;
              case 'module':
                return module;
              // But for all other dependencies, we can just go ahead and
              // require them.
              default:
                return req(dep);
            }
          }),
        );
        if (returnExports) module.exports = returnExports;
        return module;
      },
    };
  };
  window.define.amd = {};
  window.require.tlns = {};
  window.initBaseUrls = function initBaseUrls(topLevelNamespaces) {
    for (var i in topLevelNamespaces) this.require.tlns[i] = topLevelNamespaces[i];
  };

  window.initSender = function initSender() {
    var EventEmitter = window.require('ace/lib/event_emitter').EventEmitter;
    var oop = window.require('ace/lib/oop');

    var Sender = function () {};

    (function () {
      oop.implement(this, EventEmitter);

      this.callback = function (data, callbackId) {
        postMessage({
          type: 'call',
          id: callbackId,
          data: data,
        });
      };

      this.emit = function (name, data) {
        postMessage({
          type: 'event',
          name: name,
          data: data,
        });
      };
    }.call(Sender.prototype));

    return new Sender();
  };

  var main = (window.main = null);
  var sender = (window.sender = null);

  window.onmessage = function (e) {
    var msg = e.data;
    if (msg.event && sender) {
      sender._signal(msg.event, msg.data);
    } else if (msg.command) {
      if (main[msg.command]) main[msg.command].apply(main, msg.args);
      else if (window[msg.command]) window[msg.command].apply(window, msg.args);
      else throw new Error('Unknown command:' + msg.command);
    } else if (msg.init) {
      window.initBaseUrls(msg.tlns);
      sender = window.sender = window.initSender();
      var clazz = this.require(msg.module)[msg.classname];
      main = window.main = new clazz(sender);
    }
  };
})(this);

ace.define('ace/lib/oop', [], function (require, exports, module) {
  'use strict';
  exports.inherits = function (ctor, superCtor) {
    ctor.super_ = superCtor;
    ctor.prototype = Object.create(superCtor.prototype, {
      constructor: {
        value: ctor,
        enumerable: false,
        writable: true,
        configurable: true,
      },
    });
  };
  exports.mixin = function (obj, mixin) {
    for (var key in mixin) {
      obj[key] = mixin[key];
    }
    return obj;
  };
  exports.implement = function (proto, mixin) {
    exports.mixin(proto, mixin);
  };
});

ace.define('ace/apply_delta', [], function (require, exports, module) {
  'use strict';
  function throwDeltaError(delta, errorText) {
    console.log('Invalid Delta:', delta);
    throw 'Invalid Delta: ' + errorText;
  }
  function positionInDocument(docLines, position) {
    return (
      position.row >= 0 &&
      position.row < docLines.length &&
      position.column >= 0 &&
      position.column <= docLines[position.row].length
    );
  }
  function validateDelta(docLines, delta) {
    if (delta.action != 'insert' && delta.action != 'remove')
      throwDeltaError(delta, "delta.action must be 'insert' or 'remove'");
    if (!(delta.lines instanceof Array)) throwDeltaError(delta, 'delta.lines must be an Array');
    if (!delta.start || !delta.end) throwDeltaError(delta, 'delta.start/end must be an present');
    var start = delta.start;
    if (!positionInDocument(docLines, delta.start)) throwDeltaError(delta, 'delta.start must be contained in document');
    var end = delta.end;
    if (delta.action == 'remove' && !positionInDocument(docLines, end))
      throwDeltaError(delta, "delta.end must contained in document for 'remove' actions");
    var numRangeRows = end.row - start.row;
    var numRangeLastLineChars = end.column - (numRangeRows == 0 ? start.column : 0);
    if (numRangeRows != delta.lines.length - 1 || delta.lines[numRangeRows].length != numRangeLastLineChars)
      throwDeltaError(delta, 'delta.range must match delta lines');
  }
  exports.applyDelta = function (docLines, delta, doNotValidate) {
    var row = delta.start.row;
    var startColumn = delta.start.column;
    var line = docLines[row] || '';
    switch (delta.action) {
      case 'insert':
        var lines = delta.lines;
        if (lines.length === 1) {
          docLines[row] = line.substring(0, startColumn) + delta.lines[0] + line.substring(startColumn);
        } else {
          var args = [row, 1].concat(delta.lines);
          docLines.splice.apply(docLines, args);
          docLines[row] = line.substring(0, startColumn) + docLines[row];
          docLines[row + delta.lines.length - 1] += line.substring(startColumn);
        }
        break;
      case 'remove':
        var endColumn = delta.end.column;
        var endRow = delta.end.row;
        if (row === endRow) {
          docLines[row] = line.substring(0, startColumn) + line.substring(endColumn);
        } else {
          docLines.splice(
            row,
            endRow - row + 1,
            line.substring(0, startColumn) + docLines[endRow].substring(endColumn),
          );
        }
        break;
    }
  };
});

ace.define('ace/lib/event_emitter', [], function (require, exports, module) {
  'use strict';
  var EventEmitter = {};
  var stopPropagation = function () {
    this.propagationStopped = true;
  };
  var preventDefault = function () {
    this.defaultPrevented = true;
  };
  EventEmitter._emit = EventEmitter._dispatchEvent = function (eventName, e) {
    this._eventRegistry || (this._eventRegistry = {});
    this._defaultHandlers || (this._defaultHandlers = {});
    var listeners = this._eventRegistry[eventName] || [];
    var defaultHandler = this._defaultHandlers[eventName];
    if (!listeners.length && !defaultHandler) return;
    if (typeof e != 'object' || !e) e = {};
    if (!e.type) e.type = eventName;
    if (!e.stopPropagation) e.stopPropagation = stopPropagation;
    if (!e.preventDefault) e.preventDefault = preventDefault;
    listeners = listeners.slice();
    for (var i = 0; i < listeners.length; i++) {
      listeners[i](e, this);
      if (e.propagationStopped) break;
    }
    if (defaultHandler && !e.defaultPrevented) return defaultHandler(e, this);
  };
  EventEmitter._signal = function (eventName, e) {
    var listeners = (this._eventRegistry || {})[eventName];
    if (!listeners) return;
    listeners = listeners.slice();
    for (var i = 0; i < listeners.length; i++) listeners[i](e, this);
  };
  EventEmitter.once = function (eventName, callback) {
    var _self = this;
    this.on(eventName, function newCallback() {
      _self.off(eventName, newCallback);
      callback.apply(null, arguments);
    });
    if (!callback) {
      return new Promise(function (resolve) {
        callback = resolve;
      });
    }
  };
  EventEmitter.setDefaultHandler = function (eventName, callback) {
    var handlers = this._defaultHandlers;
    if (!handlers) handlers = this._defaultHandlers = { _disabled_: {} };
    if (handlers[eventName]) {
      var old = handlers[eventName];
      var disabled = handlers._disabled_[eventName];
      if (!disabled) handlers._disabled_[eventName] = disabled = [];
      disabled.push(old);
      var i = disabled.indexOf(callback);
      if (i != -1) disabled.splice(i, 1);
    }
    handlers[eventName] = callback;
  };
  EventEmitter.removeDefaultHandler = function (eventName, callback) {
    var handlers = this._defaultHandlers;
    if (!handlers) return;
    var disabled = handlers._disabled_[eventName];
    if (handlers[eventName] == callback) {
      if (disabled) this.setDefaultHandler(eventName, disabled.pop());
    } else if (disabled) {
      var i = disabled.indexOf(callback);
      if (i != -1) disabled.splice(i, 1);
    }
  };
  EventEmitter.on = EventEmitter.addEventListener = function (eventName, callback, capturing) {
    this._eventRegistry = this._eventRegistry || {};
    var listeners = this._eventRegistry[eventName];
    if (!listeners) listeners = this._eventRegistry[eventName] = [];
    if (listeners.indexOf(callback) == -1) listeners[capturing ? 'unshift' : 'push'](callback);
    return callback;
  };
  EventEmitter.off =
    EventEmitter.removeListener =
    EventEmitter.removeEventListener =
      function (eventName, callback) {
        this._eventRegistry = this._eventRegistry || {};
        var listeners = this._eventRegistry[eventName];
        if (!listeners) return;
        var index = listeners.indexOf(callback);
        if (index !== -1) listeners.splice(index, 1);
      };
  EventEmitter.removeAllListeners = function (eventName) {
    if (!eventName) this._eventRegistry = this._defaultHandlers = undefined;
    if (this._eventRegistry) this._eventRegistry[eventName] = undefined;
    if (this._defaultHandlers) this._defaultHandlers[eventName] = undefined;
  };
  exports.EventEmitter = EventEmitter;
});

ace.define('ace/range', [], function (require, exports, module) {
  'use strict';
  var comparePoints = function (p1, p2) {
    return p1.row - p2.row || p1.column - p2.column;
  };
  var Range = function (startRow, startColumn, endRow, endColumn) {
    this.start = {
      row: startRow,
      column: startColumn,
    };
    this.end = {
      row: endRow,
      column: endColumn,
    };
  };
  (function () {
    this.isEqual = function (range) {
      return (
        this.start.row === range.start.row &&
        this.end.row === range.end.row &&
        this.start.column === range.start.column &&
        this.end.column === range.end.column
      );
    };
    this.toString = function () {
      return (
        'Range: [' + this.start.row + '/' + this.start.column + '] -> [' + this.end.row + '/' + this.end.column + ']'
      );
    };
    this.contains = function (row, column) {
      return this.compare(row, column) == 0;
    };
    this.compareRange = function (range) {
      var cmp,
        end = range.end,
        start = range.start;
      cmp = this.compare(end.row, end.column);
      if (cmp == 1) {
        cmp = this.compare(start.row, start.column);
        if (cmp == 1) {
          return 2;
        } else if (cmp == 0) {
          return 1;
        } else {
          return 0;
        }
      } else if (cmp == -1) {
        return -2;
      } else {
        cmp = this.compare(start.row, start.column);
        if (cmp == -1) {
          return -1;
        } else if (cmp == 1) {
          return 42;
        } else {
          return 0;
        }
      }
    };
    this.comparePoint = function (p) {
      return this.compare(p.row, p.column);
    };
    this.containsRange = function (range) {
      return this.comparePoint(range.start) == 0 && this.comparePoint(range.end) == 0;
    };
    this.intersects = function (range) {
      var cmp = this.compareRange(range);
      return cmp == -1 || cmp == 0 || cmp == 1;
    };
    this.isEnd = function (row, column) {
      return this.end.row == row && this.end.column == column;
    };
    this.isStart = function (row, column) {
      return this.start.row == row && this.start.column == column;
    };
    this.setStart = function (row, column) {
      if (typeof row == 'object') {
        this.start.column = row.column;
        this.start.row = row.row;
      } else {
        this.start.row = row;
        this.start.column = column;
      }
    };
    this.setEnd = function (row, column) {
      if (typeof row == 'object') {
        this.end.column = row.column;
        this.end.row = row.row;
      } else {
        this.end.row = row;
        this.end.column = column;
      }
    };
    this.inside = function (row, column) {
      if (this.compare(row, column) == 0) {
        if (this.isEnd(row, column) || this.isStart(row, column)) {
          return false;
        } else {
          return true;
        }
      }
      return false;
    };
    this.insideStart = function (row, column) {
      if (this.compare(row, column) == 0) {
        if (this.isEnd(row, column)) {
          return false;
        } else {
          return true;
        }
      }
      return false;
    };
    this.insideEnd = function (row, column) {
      if (this.compare(row, column) == 0) {
        if (this.isStart(row, column)) {
          return false;
        } else {
          return true;
        }
      }
      return false;
    };
    this.compare = function (row, column) {
      if (!this.isMultiLine()) {
        if (row === this.start.row) {
          return column < this.start.column ? -1 : column > this.end.column ? 1 : 0;
        }
      }
      if (row < this.start.row) return -1;
      if (row > this.end.row) return 1;
      if (this.start.row === row) return column >= this.start.column ? 0 : -1;
      if (this.end.row === row) return column <= this.end.column ? 0 : 1;
      return 0;
    };
    this.compareStart = function (row, column) {
      if (this.start.row == row && this.start.column == column) {
        return -1;
      } else {
        return this.compare(row, column);
      }
    };
    this.compareEnd = function (row, column) {
      if (this.end.row == row && this.end.column == column) {
        return 1;
      } else {
        return this.compare(row, column);
      }
    };
    this.compareInside = function (row, column) {
      if (this.end.row == row && this.end.column == column) {
        return 1;
      } else if (this.start.row == row && this.start.column == column) {
        return -1;
      } else {
        return this.compare(row, column);
      }
    };
    this.clipRows = function (firstRow, lastRow) {
      if (this.end.row > lastRow) var end = { row: lastRow + 1, column: 0 };
      else if (this.end.row < firstRow) var end = { row: firstRow, column: 0 };
      if (this.start.row > lastRow) var start = { row: lastRow + 1, column: 0 };
      else if (this.start.row < firstRow) var start = { row: firstRow, column: 0 };
      return Range.fromPoints(start || this.start, end || this.end);
    };
    this.extend = function (row, column) {
      var cmp = this.compare(row, column);
      if (cmp == 0) return this;
      else if (cmp == -1) var start = { row: row, column: column };
      else var end = { row: row, column: column };
      return Range.fromPoints(start || this.start, end || this.end);
    };
    this.isEmpty = function () {
      return this.start.row === this.end.row && this.start.column === this.end.column;
    };
    this.isMultiLine = function () {
      return this.start.row !== this.end.row;
    };
    this.clone = function () {
      return Range.fromPoints(this.start, this.end);
    };
    this.collapseRows = function () {
      if (this.end.column == 0) return new Range(this.start.row, 0, Math.max(this.start.row, this.end.row - 1), 0);
      else return new Range(this.start.row, 0, this.end.row, 0);
    };
    this.toScreenRange = function (session) {
      var screenPosStart = session.documentToScreenPosition(this.start);
      var screenPosEnd = session.documentToScreenPosition(this.end);
      return new Range(screenPosStart.row, screenPosStart.column, screenPosEnd.row, screenPosEnd.column);
    };
    this.moveBy = function (row, column) {
      this.start.row += row;
      this.start.column += column;
      this.end.row += row;
      this.end.column += column;
    };
  }.call(Range.prototype));
  Range.fromPoints = function (start, end) {
    return new Range(start.row, start.column, end.row, end.column);
  };
  Range.comparePoints = comparePoints;
  Range.comparePoints = function (p1, p2) {
    return p1.row - p2.row || p1.column - p2.column;
  };
  exports.Range = Range;
});

ace.define('ace/anchor', [], function (require, exports, module) {
  'use strict';
  var oop = require('./lib/oop');
  var EventEmitter = require('./lib/event_emitter').EventEmitter;
  var Anchor = (exports.Anchor = function (doc, row, column) {
    this.$onChange = this.onChange.bind(this);
    this.attach(doc);
    if (typeof column == 'undefined') this.setPosition(row.row, row.column);
    else this.setPosition(row, column);
  });
  (function () {
    oop.implement(this, EventEmitter);
    this.getPosition = function () {
      return this.$clipPositionToDocument(this.row, this.column);
    };
    this.getDocument = function () {
      return this.document;
    };
    this.$insertRight = false;
    this.onChange = function (delta) {
      if (delta.start.row == delta.end.row && delta.start.row != this.row) return;
      if (delta.start.row > this.row) return;
      var point = $getTransformedPoint(delta, { row: this.row, column: this.column }, this.$insertRight);
      this.setPosition(point.row, point.column, true);
    };
    function $pointsInOrder(point1, point2, equalPointsInOrder) {
      var bColIsAfter = equalPointsInOrder ? point1.column <= point2.column : point1.column < point2.column;
      return point1.row < point2.row || (point1.row == point2.row && bColIsAfter);
    }
    function $getTransformedPoint(delta, point, moveIfEqual) {
      var deltaIsInsert = delta.action == 'insert';
      var deltaRowShift = (deltaIsInsert ? 1 : -1) * (delta.end.row - delta.start.row);
      var deltaColShift = (deltaIsInsert ? 1 : -1) * (delta.end.column - delta.start.column);
      var deltaStart = delta.start;
      var deltaEnd = deltaIsInsert ? deltaStart : delta.end; // Collapse insert range.
      if ($pointsInOrder(point, deltaStart, moveIfEqual)) {
        return {
          row: point.row,
          column: point.column,
        };
      }
      if ($pointsInOrder(deltaEnd, point, !moveIfEqual)) {
        return {
          row: point.row + deltaRowShift,
          column: point.column + (point.row == deltaEnd.row ? deltaColShift : 0),
        };
      }
      return {
        row: deltaStart.row,
        column: deltaStart.column,
      };
    }
    this.setPosition = function (row, column, noClip) {
      var pos;
      if (noClip) {
        pos = {
          row: row,
          column: column,
        };
      } else {
        pos = this.$clipPositionToDocument(row, column);
      }
      if (this.row == pos.row && this.column == pos.column) return;
      var old = {
        row: this.row,
        column: this.column,
      };
      this.row = pos.row;
      this.column = pos.column;
      this._signal('change', {
        old: old,
        value: pos,
      });
    };
    this.detach = function () {
      this.document.off('change', this.$onChange);
    };
    this.attach = function (doc) {
      this.document = doc || this.document;
      this.document.on('change', this.$onChange);
    };
    this.$clipPositionToDocument = function (row, column) {
      var pos = {};
      if (row >= this.document.getLength()) {
        pos.row = Math.max(0, this.document.getLength() - 1);
        pos.column = this.document.getLine(pos.row).length;
      } else if (row < 0) {
        pos.row = 0;
        pos.column = 0;
      } else {
        pos.row = row;
        pos.column = Math.min(this.document.getLine(pos.row).length, Math.max(0, column));
      }
      if (column < 0) pos.column = 0;
      return pos;
    };
  }.call(Anchor.prototype));
});

ace.define('ace/document', [], function (require, exports, module) {
  'use strict';
  var oop = require('./lib/oop');
  var applyDelta = require('./apply_delta').applyDelta;
  var EventEmitter = require('./lib/event_emitter').EventEmitter;
  var Range = require('./range').Range;
  var Anchor = require('./anchor').Anchor;
  var Document = function (textOrLines) {
    this.$lines = [''];
    if (textOrLines.length === 0) {
      this.$lines = [''];
    } else if (Array.isArray(textOrLines)) {
      this.insertMergedLines({ row: 0, column: 0 }, textOrLines);
    } else {
      this.insert({ row: 0, column: 0 }, textOrLines);
    }
  };
  (function () {
    oop.implement(this, EventEmitter);
    this.setValue = function (text) {
      var len = this.getLength() - 1;
      this.remove(new Range(0, 0, len, this.getLine(len).length));
      this.insert({ row: 0, column: 0 }, text || '');
    };
    this.getValue = function () {
      return this.getAllLines().join(this.getNewLineCharacter());
    };
    this.createAnchor = function (row, column) {
      return new Anchor(this, row, column);
    };
    if ('aaa'.split(/a/).length === 0) {
      this.$split = function (text) {
        return text.replace(/\r\n|\r/g, '\n').split('\n');
      };
    } else {
      this.$split = function (text) {
        return text.split(/\r\n|\r|\n/);
      };
    }
    this.$detectNewLine = function (text) {
      var match = text.match(/^.*?(\r\n|\r|\n)/m);
      this.$autoNewLine = match ? match[1] : '\n';
      this._signal('changeNewLineMode');
    };
    this.getNewLineCharacter = function () {
      switch (this.$newLineMode) {
        case 'windows':
          return '\r\n';
        case 'unix':
          return '\n';
        default:
          return this.$autoNewLine || '\n';
      }
    };
    this.$autoNewLine = '';
    this.$newLineMode = 'auto';
    this.setNewLineMode = function (newLineMode) {
      if (this.$newLineMode === newLineMode) return;
      this.$newLineMode = newLineMode;
      this._signal('changeNewLineMode');
    };
    this.getNewLineMode = function () {
      return this.$newLineMode;
    };
    this.isNewLine = function (text) {
      return text == '\r\n' || text == '\r' || text == '\n';
    };
    this.getLine = function (row) {
      return this.$lines[row] || '';
    };
    this.getLines = function (firstRow, lastRow) {
      return this.$lines.slice(firstRow, lastRow + 1);
    };
    this.getAllLines = function () {
      return this.getLines(0, this.getLength());
    };
    this.getLength = function () {
      return this.$lines.length;
    };
    this.getTextRange = function (range) {
      return this.getLinesForRange(range).join(this.getNewLineCharacter());
    };
    this.getLinesForRange = function (range) {
      var lines;
      if (range.start.row === range.end.row) {
        lines = [this.getLine(range.start.row).substring(range.start.column, range.end.column)];
      } else {
        lines = this.getLines(range.start.row, range.end.row);
        lines[0] = (lines[0] || '').substring(range.start.column);
        var l = lines.length - 1;
        if (range.end.row - range.start.row == l) lines[l] = lines[l].substring(0, range.end.column);
      }
      return lines;
    };
    this.insertLines = function (row, lines) {
      console.warn('Use of document.insertLines is deprecated. Use the insertFullLines method instead.');
      return this.insertFullLines(row, lines);
    };
    this.removeLines = function (firstRow, lastRow) {
      console.warn('Use of document.removeLines is deprecated. Use the removeFullLines method instead.');
      return this.removeFullLines(firstRow, lastRow);
    };
    this.insertNewLine = function (position) {
      console.warn("Use of document.insertNewLine is deprecated. Use insertMergedLines(position, ['', '']) instead.");
      return this.insertMergedLines(position, ['', '']);
    };
    this.insert = function (position, text) {
      if (this.getLength() <= 1) this.$detectNewLine(text);
      return this.insertMergedLines(position, this.$split(text));
    };
    this.insertInLine = function (position, text) {
      var start = this.clippedPos(position.row, position.column);
      var end = this.pos(position.row, position.column + text.length);
      this.applyDelta(
        {
          start: start,
          end: end,
          action: 'insert',
          lines: [text],
        },
        true,
      );
      return this.clonePos(end);
    };
    this.clippedPos = function (row, column) {
      var length = this.getLength();
      if (row === undefined) {
        row = length;
      } else if (row < 0) {
        row = 0;
      } else if (row >= length) {
        row = length - 1;
        column = undefined;
      }
      var line = this.getLine(row);
      if (column == undefined) column = line.length;
      column = Math.min(Math.max(column, 0), line.length);
      return { row: row, column: column };
    };
    this.clonePos = function (pos) {
      return { row: pos.row, column: pos.column };
    };
    this.pos = function (row, column) {
      return { row: row, column: column };
    };
    this.$clipPosition = function (position) {
      var length = this.getLength();
      if (position.row >= length) {
        position.row = Math.max(0, length - 1);
        position.column = this.getLine(length - 1).length;
      } else {
        position.row = Math.max(0, position.row);
        position.column = Math.min(Math.max(position.column, 0), this.getLine(position.row).length);
      }
      return position;
    };
    this.insertFullLines = function (row, lines) {
      row = Math.min(Math.max(row, 0), this.getLength());
      var column = 0;
      if (row < this.getLength()) {
        lines = lines.concat(['']);
        column = 0;
      } else {
        lines = [''].concat(lines);
        row--;
        column = this.$lines[row].length;
      }
      this.insertMergedLines({ row: row, column: column }, lines);
    };
    this.insertMergedLines = function (position, lines) {
      var start = this.clippedPos(position.row, position.column);
      var end = {
        row: start.row + lines.length - 1,
        column: (lines.length == 1 ? start.column : 0) + lines[lines.length - 1].length,
      };
      this.applyDelta({
        start: start,
        end: end,
        action: 'insert',
        lines: lines,
      });
      return this.clonePos(end);
    };
    this.remove = function (range) {
      var start = this.clippedPos(range.start.row, range.start.column);
      var end = this.clippedPos(range.end.row, range.end.column);
      this.applyDelta({
        start: start,
        end: end,
        action: 'remove',
        lines: this.getLinesForRange({ start: start, end: end }),
      });
      return this.clonePos(start);
    };
    this.removeInLine = function (row, startColumn, endColumn) {
      var start = this.clippedPos(row, startColumn);
      var end = this.clippedPos(row, endColumn);
      this.applyDelta(
        {
          start: start,
          end: end,
          action: 'remove',
          lines: this.getLinesForRange({ start: start, end: end }),
        },
        true,
      );
      return this.clonePos(start);
    };
    this.removeFullLines = function (firstRow, lastRow) {
      firstRow = Math.min(Math.max(0, firstRow), this.getLength() - 1);
      lastRow = Math.min(Math.max(0, lastRow), this.getLength() - 1);
      var deleteFirstNewLine = lastRow == this.getLength() - 1 && firstRow > 0;
      var deleteLastNewLine = lastRow < this.getLength() - 1;
      var startRow = deleteFirstNewLine ? firstRow - 1 : firstRow;
      var startCol = deleteFirstNewLine ? this.getLine(startRow).length : 0;
      var endRow = deleteLastNewLine ? lastRow + 1 : lastRow;
      var endCol = deleteLastNewLine ? 0 : this.getLine(endRow).length;
      var range = new Range(startRow, startCol, endRow, endCol);
      var deletedLines = this.$lines.slice(firstRow, lastRow + 1);
      this.applyDelta({
        start: range.start,
        end: range.end,
        action: 'remove',
        lines: this.getLinesForRange(range),
      });
      return deletedLines;
    };
    this.removeNewLine = function (row) {
      if (row < this.getLength() - 1 && row >= 0) {
        this.applyDelta({
          start: this.pos(row, this.getLine(row).length),
          end: this.pos(row + 1, 0),
          action: 'remove',
          lines: ['', ''],
        });
      }
    };
    this.replace = function (range, text) {
      if (!(range instanceof Range)) range = Range.fromPoints(range.start, range.end);
      if (text.length === 0 && range.isEmpty()) return range.start;
      if (text == this.getTextRange(range)) return range.end;
      this.remove(range);
      var end;
      if (text) {
        end = this.insert(range.start, text);
      } else {
        end = range.start;
      }
      return end;
    };
    this.applyDeltas = function (deltas) {
      for (var i = 0; i < deltas.length; i++) {
        this.applyDelta(deltas[i]);
      }
    };
    this.revertDeltas = function (deltas) {
      for (var i = deltas.length - 1; i >= 0; i--) {
        this.revertDelta(deltas[i]);
      }
    };
    this.applyDelta = function (delta, doNotValidate) {
      var isInsert = delta.action == 'insert';
      if (isInsert ? delta.lines.length <= 1 && !delta.lines[0] : !Range.comparePoints(delta.start, delta.end)) {
        return;
      }
      if (isInsert && delta.lines.length > 20000) {
        this.$splitAndapplyLargeDelta(delta, 20000);
      } else {
        applyDelta(this.$lines, delta, doNotValidate);
        this._signal('change', delta);
      }
    };
    this.$safeApplyDelta = function (delta) {
      var docLength = this.$lines.length;
      if (
        (delta.action == 'remove' && delta.start.row < docLength && delta.end.row < docLength) ||
        (delta.action == 'insert' && delta.start.row <= docLength)
      ) {
        this.applyDelta(delta);
      }
    };
    this.$splitAndapplyLargeDelta = function (delta, MAX) {
      var lines = delta.lines;
      var l = lines.length - MAX + 1;
      var row = delta.start.row;
      var column = delta.start.column;
      for (var from = 0, to = 0; from < l; from = to) {
        to += MAX - 1;
        var chunk = lines.slice(from, to);
        chunk.push('');
        this.applyDelta(
          {
            start: this.pos(row + from, column),
            end: this.pos(row + to, (column = 0)),
            action: delta.action,
            lines: chunk,
          },
          true,
        );
      }
      delta.lines = lines.slice(from);
      delta.start.row = row + from;
      delta.start.column = column;
      this.applyDelta(delta, true);
    };
    this.revertDelta = function (delta) {
      this.$safeApplyDelta({
        start: this.clonePos(delta.start),
        end: this.clonePos(delta.end),
        action: delta.action == 'insert' ? 'remove' : 'insert',
        lines: delta.lines.slice(),
      });
    };
    this.indexToPosition = function (index, startRow) {
      var lines = this.$lines || this.getAllLines();
      var newlineLength = this.getNewLineCharacter().length;
      for (var i = startRow || 0, l = lines.length; i < l; i++) {
        index -= lines[i].length + newlineLength;
        if (index < 0) return { row: i, column: index + lines[i].length + newlineLength };
      }
      return { row: l - 1, column: index + lines[l - 1].length + newlineLength };
    };
    this.positionToIndex = function (pos, startRow) {
      var lines = this.$lines || this.getAllLines();
      var newlineLength = this.getNewLineCharacter().length;
      var index = 0;
      var row = Math.min(pos.row, lines.length);
      for (var i = startRow || 0; i < row; ++i) index += lines[i].length + newlineLength;
      return index + pos.column;
    };
  }.call(Document.prototype));
  exports.Document = Document;
});

ace.define('ace/lib/lang', [], function (require, exports, module) {
  'use strict';
  exports.last = function (a) {
    return a[a.length - 1];
  };
  exports.stringReverse = function (string) {
    return string.split('').reverse().join('');
  };
  exports.stringRepeat = function (string, count) {
    var result = '';
    while (count > 0) {
      if (count & 1) result += string;
      if ((count >>= 1)) string += string;
    }
    return result;
  };
  var trimBeginRegexp = /^\s\s*/;
  var trimEndRegexp = /\s\s*$/;
  exports.stringTrimLeft = function (string) {
    return string.replace(trimBeginRegexp, '');
  };
  exports.stringTrimRight = function (string) {
    return string.replace(trimEndRegexp, '');
  };
  exports.copyObject = function (obj) {
    var copy = {};
    for (var key in obj) {
      copy[key] = obj[key];
    }
    return copy;
  };
  exports.copyArray = function (array) {
    var copy = [];
    for (var i = 0, l = array.length; i < l; i++) {
      if (array[i] && typeof array[i] == 'object') copy[i] = this.copyObject(array[i]);
      else copy[i] = array[i];
    }
    return copy;
  };
  exports.deepCopy = function deepCopy(obj) {
    if (typeof obj !== 'object' || !obj) return obj;
    var copy;
    if (Array.isArray(obj)) {
      copy = [];
      for (var key = 0; key < obj.length; key++) {
        copy[key] = deepCopy(obj[key]);
      }
      return copy;
    }
    if (Object.prototype.toString.call(obj) !== '[object Object]') return obj;
    copy = {};
    for (var key in obj) copy[key] = deepCopy(obj[key]);
    return copy;
  };
  exports.arrayToMap = function (arr) {
    var map = {};
    for (var i = 0; i < arr.length; i++) {
      map[arr[i]] = 1;
    }
    return map;
  };
  exports.createMap = function (props) {
    var map = Object.create(null);
    for (var i in props) {
      map[i] = props[i];
    }
    return map;
  };
  exports.arrayRemove = function (array, value) {
    for (var i = 0; i <= array.length; i++) {
      if (value === array[i]) {
        array.splice(i, 1);
      }
    }
  };
  exports.escapeRegExp = function (str) {
    return str.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1');
  };
  exports.escapeHTML = function (str) {
    return ('' + str).replace(/&/g, '&#38;').replace(/"/g, '&#34;').replace(/'/g, '&#39;').replace(/</g, '&#60;');
  };
  exports.getMatchOffsets = function (string, regExp) {
    var matches = [];
    string.replace(regExp, function (str) {
      matches.push({
        offset: arguments[arguments.length - 2],
        length: str.length,
      });
    });
    return matches;
  };
  exports.deferredCall = function (fcn) {
    var timer = null;
    var callback = function () {
      timer = null;
      fcn();
    };
    var deferred = function (timeout) {
      deferred.cancel();
      timer = setTimeout(callback, timeout || 0);
      return deferred;
    };
    deferred.schedule = deferred;
    deferred.call = function () {
      this.cancel();
      fcn();
      return deferred;
    };
    deferred.cancel = function () {
      clearTimeout(timer);
      timer = null;
      return deferred;
    };
    deferred.isPending = function () {
      return timer;
    };
    return deferred;
  };
  exports.delayedCall = function (fcn, defaultTimeout) {
    var timer = null;
    var callback = function () {
      timer = null;
      fcn();
    };
    var _self = function (timeout) {
      if (timer == null) timer = setTimeout(callback, timeout || defaultTimeout);
    };
    _self.delay = function (timeout) {
      timer && clearTimeout(timer);
      timer = setTimeout(callback, timeout || defaultTimeout);
    };
    _self.schedule = _self;
    _self.call = function () {
      this.cancel();
      fcn();
    };
    _self.cancel = function () {
      timer && clearTimeout(timer);
      timer = null;
    };
    _self.isPending = function () {
      return timer;
    };
    return _self;
  };
});

ace.define('ace/worker/mirror', [], function (require, exports, module) {
  'use strict';

  var Document = require('../document').Document;
  var lang = require('../lib/lang');

  var Mirror = (exports.Mirror = function (sender) {
    this.sender = sender;
    var doc = (this.doc = new Document(''));

    var deferredUpdate = (this.deferredUpdate = lang.delayedCall(this.onUpdate.bind(this)));

    var _self = this;
    sender.on('change', function (e) {
      var data = e.data;
      if (data[0].start) {
        doc.applyDeltas(data);
      } else {
        for (var i = 0; i < data.length; i += 2) {
          var d, err;
          if (Array.isArray(data[i + 1])) {
            d = { action: 'insert', start: data[i], lines: data[i + 1] };
          } else {
            d = { action: 'remove', start: data[i], end: data[i + 1] };
          }

          if ((d.action == 'insert' ? d.start : d.end).row >= doc.$lines.length) {
            err = new Error('Invalid delta');
            err.data = {
              path: _self.$path,
              linesLength: doc.$lines.length,
              start: d.start,
              end: d.end,
            };
            throw err;
          }

          doc.applyDelta(d, true);
        }
      }
      if (_self.$timeout) return deferredUpdate.schedule(_self.$timeout);
      _self.onUpdate();
    });
  });

  (function () {
    this.$timeout = 500;

    this.setTimeout = function (timeout) {
      this.$timeout = timeout;
    };

    this.setValue = function (value) {
      this.doc.setValue(value);
      this.deferredUpdate.schedule(this.$timeout);
    };

    this.getValue = function (callbackId) {
      this.sender.callback(this.doc.getValue(), callbackId);
    };

    this.onUpdate = function () {};

    this.isPending = function () {
      return this.deferredUpdate.isPending();
    };
  }.call(Mirror.prototype));
});

ace.define('ace/mode/yaml/yaml-lint', [], function (require, exports, module) {
  var $build_deps$ = { require: require, exports: exports, module: module };
  exports = undefined;
  module = undefined;
  function define(name, deps, m) {
    if (typeof name == 'function') {
      m = name;
      deps = ['require', 'exports', 'module'];
      name = $build_deps$.module.id;
    }
    if (typeof name !== 'string') {
      m = deps;
      deps = name;
      name = $build_deps$.module.id;
    }
    if (!m) {
      m = deps;
      deps = [];
    }
    var ret =
      typeof m == 'function'
        ? m.apply(
            $build_deps$.module,
            deps.map(function (n) {
              return $build_deps$[n] || require(n);
            }),
          )
        : m;
    if (ret != undefined) $build_deps$.module.exports = ret;
  }
  define.amd = true;
  (function (f) {
    if (typeof exports === 'object' && typeof module !== 'undefined') {
      module.exports = f();
    } else if (typeof define === 'function' && define.amd) {
      define([], f);
    } else {
      var g;
      if (typeof window !== 'undefined') {
        g = window;
      } else if (typeof global !== 'undefined') {
        g = global;
      } else if (typeof self !== 'undefined') {
        g = self;
      } else {
        g = this;
      }
      g.lint = f();
    }
  })(function () {
    var define, module, exports;
    return (function () {
      function r(e, n, t) {
        function o(i, f) {
          if (!n[i]) {
            if (!e[i]) {
              var c = typeof require == 'function' && require;
              if (!f && c) return c(i, !0);
              if (u) return u(i, !0);
              var a = new Error("Cannot find module '" + i + "'");
              throw ((a.code = 'MODULE_NOT_FOUND'), a);
            }
            var p = (n[i] = { exports: {} });
            e[i][0].call(
              p.exports,
              function (r) {
                var n = e[i][1][r];
                return o(n || r);
              },
              p,
              p.exports,
              r,
              e,
              n,
              t,
            );
          }
          return n[i].exports;
        }
        for (var u = typeof require == 'function' && require, i = 0; i < t.length; i++) o(t[i]);
        return o;
      }
      return r;
    })()(
      {
        1: [function (require, module, exports) {}, {}],
        2: [
          function (require, module, exports) {
            var fs = require('fs');
            var merge = require('lodash.merge');
            var yaml = require('js-yaml');

            var DEFAULT_LINT_OPTION = {
              schema: 'DEFAULT_SAFE_SCHEMA',
            };

            function lint(content, opts, cb) {
              var options = merge({}, DEFAULT_LINT_OPTION, opts);
              try {
                yaml.safeLoad(content, {
                  schema: yaml[options.schema],
                });
                cb();
              } catch (e) {
                cb(e);
              }
            }

            module.exports = {
              lint: lint,
            };
          },
          { fs: 1, 'js-yaml': 3, 'lodash.merge': 33 },
        ],
        3: [
          function (require, module, exports) {
            'use strict';

            var yaml = require('./lib/js-yaml.js');

            module.exports = yaml;
          },
          { './lib/js-yaml.js': 4 },
        ],
        4: [
          function (require, module, exports) {
            'use strict';

            var loader = require('./js-yaml/loader');
            var dumper = require('./js-yaml/dumper');

            function deprecated(name) {
              return function () {
                throw new Error('Function ' + name + ' is deprecated and cannot be used.');
              };
            }

            module.exports.Type = require('./js-yaml/type');
            module.exports.Schema = require('./js-yaml/schema');
            module.exports.FAILSAFE_SCHEMA = require('./js-yaml/schema/failsafe');
            module.exports.JSON_SCHEMA = require('./js-yaml/schema/json');
            module.exports.CORE_SCHEMA = require('./js-yaml/schema/core');
            module.exports.DEFAULT_SAFE_SCHEMA = require('./js-yaml/schema/default_safe');
            module.exports.DEFAULT_FULL_SCHEMA = require('./js-yaml/schema/default_full');
            module.exports.load = loader.load;
            module.exports.loadAll = loader.loadAll;
            module.exports.safeLoad = loader.safeLoad;
            module.exports.safeLoadAll = loader.safeLoadAll;
            module.exports.dump = dumper.dump;
            module.exports.safeDump = dumper.safeDump;
            module.exports.YAMLException = require('./js-yaml/exception');
            module.exports.MINIMAL_SCHEMA = require('./js-yaml/schema/failsafe');
            module.exports.SAFE_SCHEMA = require('./js-yaml/schema/default_safe');
            module.exports.DEFAULT_SCHEMA = require('./js-yaml/schema/default_full');
            module.exports.scan = deprecated('scan');
            module.exports.parse = deprecated('parse');
            module.exports.compose = deprecated('compose');
            module.exports.addConstructor = deprecated('addConstructor');
          },
          {
            './js-yaml/dumper': 6,
            './js-yaml/exception': 7,
            './js-yaml/loader': 8,
            './js-yaml/schema': 10,
            './js-yaml/schema/core': 11,
            './js-yaml/schema/default_full': 12,
            './js-yaml/schema/default_safe': 13,
            './js-yaml/schema/failsafe': 14,
            './js-yaml/schema/json': 15,
            './js-yaml/type': 16,
          },
        ],
        5: [
          function (require, module, exports) {
            'use strict';

            function isNothing(subject) {
              return typeof subject === 'undefined' || subject === null;
            }

            function isObject(subject) {
              return typeof subject === 'object' && subject !== null;
            }

            function toArray(sequence) {
              if (Array.isArray(sequence)) return sequence;
              else if (isNothing(sequence)) return [];

              return [sequence];
            }

            function extend(target, source) {
              var index, length, key, sourceKeys;

              if (source) {
                sourceKeys = Object.keys(source);

                for (index = 0, length = sourceKeys.length; index < length; index += 1) {
                  key = sourceKeys[index];
                  target[key] = source[key];
                }
              }

              return target;
            }

            function repeat(string, count) {
              var result = '',
                cycle;

              for (cycle = 0; cycle < count; cycle += 1) {
                result += string;
              }

              return result;
            }

            function isNegativeZero(number) {
              return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
            }

            module.exports.isNothing = isNothing;
            module.exports.isObject = isObject;
            module.exports.toArray = toArray;
            module.exports.repeat = repeat;
            module.exports.isNegativeZero = isNegativeZero;
            module.exports.extend = extend;
          },
          {},
        ],
        6: [
          function (require, module, exports) {
            'use strict';

            var common = require('./common');
            var YAMLException = require('./exception');
            var DEFAULT_FULL_SCHEMA = require('./schema/default_full');
            var DEFAULT_SAFE_SCHEMA = require('./schema/default_safe');

            var _toString = Object.prototype.toString;
            var _hasOwnProperty = Object.prototype.hasOwnProperty;

            var CHAR_TAB = 0x09;
            var CHAR_LINE_FEED = 0x0a;
            var CHAR_SPACE = 0x20;
            var CHAR_EXCLAMATION = 0x21;
            var CHAR_DOUBLE_QUOTE = 0x22;
            var CHAR_SHARP = 0x23;
            var CHAR_PERCENT = 0x25;
            var CHAR_AMPERSAND = 0x26;
            var CHAR_SINGLE_QUOTE = 0x27;
            var CHAR_ASTERISK = 0x2a;
            var CHAR_COMMA = 0x2c;
            var CHAR_MINUS = 0x2d;
            var CHAR_COLON = 0x3a;
            var CHAR_GREATER_THAN = 0x3e;
            var CHAR_QUESTION = 0x3f;
            var CHAR_COMMERCIAL_AT = 0x40;
            var CHAR_LEFT_SQUARE_BRACKET = 0x5b;
            var CHAR_RIGHT_SQUARE_BRACKET = 0x5d;
            var CHAR_GRAVE_ACCENT = 0x60;
            var CHAR_LEFT_CURLY_BRACKET = 0x7b;
            var CHAR_VERTICAL_LINE = 0x7c;
            var CHAR_RIGHT_CURLY_BRACKET = 0x7d;

            var ESCAPE_SEQUENCES = {};

            ESCAPE_SEQUENCES[0x00] = '\\0';
            ESCAPE_SEQUENCES[0x07] = '\\a';
            ESCAPE_SEQUENCES[0x08] = '\\b';
            ESCAPE_SEQUENCES[0x09] = '\\t';
            ESCAPE_SEQUENCES[0x0a] = '\\n';
            ESCAPE_SEQUENCES[0x0b] = '\\v';
            ESCAPE_SEQUENCES[0x0c] = '\\f';
            ESCAPE_SEQUENCES[0x0d] = '\\r';
            ESCAPE_SEQUENCES[0x1b] = '\\e';
            ESCAPE_SEQUENCES[0x22] = '\\"';
            ESCAPE_SEQUENCES[0x5c] = '\\\\';
            ESCAPE_SEQUENCES[0x85] = '\\N';
            ESCAPE_SEQUENCES[0xa0] = '\\_';
            ESCAPE_SEQUENCES[0x2028] = '\\L';
            ESCAPE_SEQUENCES[0x2029] = '\\P';

            var DEPRECATED_BOOLEANS_SYNTAX = [
              'y',
              'Y',
              'yes',
              'Yes',
              'YES',
              'on',
              'On',
              'ON',
              'n',
              'N',
              'no',
              'No',
              'NO',
              'off',
              'Off',
              'OFF',
            ];

            function compileStyleMap(schema, map) {
              var result, keys, index, length, tag, style, type;

              if (map === null) return {};

              result = {};
              keys = Object.keys(map);

              for (index = 0, length = keys.length; index < length; index += 1) {
                tag = keys[index];
                style = String(map[tag]);

                if (tag.slice(0, 2) === '!!') {
                  tag = 'tag:yaml.org,2002:' + tag.slice(2);
                }
                type = schema.compiledTypeMap['fallback'][tag];

                if (type && _hasOwnProperty.call(type.styleAliases, style)) {
                  style = type.styleAliases[style];
                }

                result[tag] = style;
              }

              return result;
            }

            function encodeHex(character) {
              var string, handle, length;

              string = character.toString(16).toUpperCase();

              if (character <= 0xff) {
                handle = 'x';
                length = 2;
              } else if (character <= 0xffff) {
                handle = 'u';
                length = 4;
              } else if (character <= 0xffffffff) {
                handle = 'U';
                length = 8;
              } else {
                throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF');
              }

              return '\\' + handle + common.repeat('0', length - string.length) + string;
            }

            function State(options) {
              this.schema = options['schema'] || DEFAULT_FULL_SCHEMA;
              this.indent = Math.max(1, options['indent'] || 2);
              this.noArrayIndent = options['noArrayIndent'] || false;
              this.skipInvalid = options['skipInvalid'] || false;
              this.flowLevel = common.isNothing(options['flowLevel']) ? -1 : options['flowLevel'];
              this.styleMap = compileStyleMap(this.schema, options['styles'] || null);
              this.sortKeys = options['sortKeys'] || false;
              this.lineWidth = options['lineWidth'] || 80;
              this.noRefs = options['noRefs'] || false;
              this.noCompatMode = options['noCompatMode'] || false;
              this.condenseFlow = options['condenseFlow'] || false;

              this.implicitTypes = this.schema.compiledImplicit;
              this.explicitTypes = this.schema.compiledExplicit;

              this.tag = null;
              this.result = '';

              this.duplicates = [];
              this.usedDuplicates = null;
            }
            function indentString(string, spaces) {
              var ind = common.repeat(' ', spaces),
                position = 0,
                next = -1,
                result = '',
                line,
                length = string.length;

              while (position < length) {
                next = string.indexOf('\n', position);
                if (next === -1) {
                  line = string.slice(position);
                  position = length;
                } else {
                  line = string.slice(position, next + 1);
                  position = next + 1;
                }

                if (line.length && line !== '\n') result += ind;

                result += line;
              }

              return result;
            }

            function generateNextLine(state, level) {
              return '\n' + common.repeat(' ', state.indent * level);
            }

            function testImplicitResolving(state, str) {
              var index, length, type;

              for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
                type = state.implicitTypes[index];

                if (type.resolve(str)) {
                  return true;
                }
              }

              return false;
            }
            function isWhitespace(c) {
              return c === CHAR_SPACE || c === CHAR_TAB;
            }
            function isPrintable(c) {
              return (
                (c >= 0x00020 && c <= 0x00007e) ||
                (c >= 0x000a1 && c <= 0x00d7ff && c !== 0x2028 && c !== 0x2029) ||
                (c >= 0x0e000 && c <= 0x00fffd && c !== 0xfeff) /* BOM */ ||
                (c >= 0x10000 && c <= 0x10ffff)
              );
            }
            function isPlainSafe(c) {
              return (
                isPrintable(c) &&
                c !== 0xfeff &&
                c !== CHAR_COMMA &&
                c !== CHAR_LEFT_SQUARE_BRACKET &&
                c !== CHAR_RIGHT_SQUARE_BRACKET &&
                c !== CHAR_LEFT_CURLY_BRACKET &&
                c !== CHAR_RIGHT_CURLY_BRACKET &&
                c !== CHAR_COLON &&
                c !== CHAR_SHARP
              );
            }
            function isPlainSafeFirst(c) {
              return (
                isPrintable(c) &&
                c !== 0xfeff &&
                !isWhitespace(c) && // - s-white
                c !== CHAR_MINUS &&
                c !== CHAR_QUESTION &&
                c !== CHAR_COLON &&
                c !== CHAR_COMMA &&
                c !== CHAR_LEFT_SQUARE_BRACKET &&
                c !== CHAR_RIGHT_SQUARE_BRACKET &&
                c !== CHAR_LEFT_CURLY_BRACKET &&
                c !== CHAR_RIGHT_CURLY_BRACKET &&
                c !== CHAR_SHARP &&
                c !== CHAR_AMPERSAND &&
                c !== CHAR_ASTERISK &&
                c !== CHAR_EXCLAMATION &&
                c !== CHAR_VERTICAL_LINE &&
                c !== CHAR_GREATER_THAN &&
                c !== CHAR_SINGLE_QUOTE &&
                c !== CHAR_DOUBLE_QUOTE &&
                c !== CHAR_PERCENT &&
                c !== CHAR_COMMERCIAL_AT &&
                c !== CHAR_GRAVE_ACCENT
              );
            }
            function needIndentIndicator(string) {
              var leadingSpaceRe = /^\n* /;
              return leadingSpaceRe.test(string);
            }

            var STYLE_PLAIN = 1,
              STYLE_SINGLE = 2,
              STYLE_LITERAL = 3,
              STYLE_FOLDED = 4,
              STYLE_DOUBLE = 5;
            function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) {
              var i;
              var char;
              var hasLineBreak = false;
              var hasFoldableLine = false; // only checked if shouldTrackWidth
              var shouldTrackWidth = lineWidth !== -1;
              var previousLineBreak = -1; // count the first line correctly
              var plain = isPlainSafeFirst(string.charCodeAt(0)) && !isWhitespace(string.charCodeAt(string.length - 1));

              if (singleLineOnly) {
                for (i = 0; i < string.length; i++) {
                  char = string.charCodeAt(i);
                  if (!isPrintable(char)) {
                    return STYLE_DOUBLE;
                  }
                  plain = plain && isPlainSafe(char);
                }
              } else {
                for (i = 0; i < string.length; i++) {
                  char = string.charCodeAt(i);
                  if (char === CHAR_LINE_FEED) {
                    hasLineBreak = true;
                    if (shouldTrackWidth) {
                      hasFoldableLine =
                        hasFoldableLine ||
                        (i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== ' ');
                      previousLineBreak = i;
                    }
                  } else if (!isPrintable(char)) {
                    return STYLE_DOUBLE;
                  }
                  plain = plain && isPlainSafe(char);
                }
                hasFoldableLine =
                  hasFoldableLine ||
                  (shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && string[previousLineBreak + 1] !== ' ');
              }
              if (!hasLineBreak && !hasFoldableLine) {
                return plain && !testAmbiguousType(string) ? STYLE_PLAIN : STYLE_SINGLE;
              }
              if (indentPerLevel > 9 && needIndentIndicator(string)) {
                return STYLE_DOUBLE;
              }
              return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
            }
            function writeScalar(state, string, level, iskey) {
              state.dump = (function () {
                if (string.length === 0) {
                  return "''";
                }
                if (!state.noCompatMode && DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) {
                  return "'" + string + "'";
                }

                var indent = state.indent * Math.max(1, level); // no 0-indent scalars
                var lineWidth =
                  state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
                var singleLineOnly = iskey || (state.flowLevel > -1 && level >= state.flowLevel);
                function testAmbiguity(string) {
                  return testImplicitResolving(state, string);
                }

                switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) {
                  case STYLE_PLAIN:
                    return string;
                  case STYLE_SINGLE:
                    return "'" + string.replace(/'/g, "''") + "'";
                  case STYLE_LITERAL:
                    return '|' + blockHeader(string, state.indent) + dropEndingNewline(indentString(string, indent));
                  case STYLE_FOLDED:
                    return (
                      '>' +
                      blockHeader(string, state.indent) +
                      dropEndingNewline(indentString(foldString(string, lineWidth), indent))
                    );
                  case STYLE_DOUBLE:
                    return '"' + escapeString(string, lineWidth) + '"';
                  default:
                    throw new YAMLException('impossible error: invalid scalar style');
                }
              })();
            }
            function blockHeader(string, indentPerLevel) {
              var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : '';
              var clip = string[string.length - 1] === '\n';
              var keep = clip && (string[string.length - 2] === '\n' || string === '\n');
              var chomp = keep ? '+' : clip ? '' : '-';

              return indentIndicator + chomp + '\n';
            }
            function dropEndingNewline(string) {
              return string[string.length - 1] === '\n' ? string.slice(0, -1) : string;
            }
            function foldString(string, width) {
              var lineRe = /(\n+)([^\n]*)/g;
              var result = (function () {
                var nextLF = string.indexOf('\n');
                nextLF = nextLF !== -1 ? nextLF : string.length;
                lineRe.lastIndex = nextLF;
                return foldLine(string.slice(0, nextLF), width);
              })();
              var prevMoreIndented = string[0] === '\n' || string[0] === ' ';
              var moreIndented;
              var match;
              while ((match = lineRe.exec(string))) {
                var prefix = match[1],
                  line = match[2];
                moreIndented = line[0] === ' ';
                result +=
                  prefix + (!prevMoreIndented && !moreIndented && line !== '' ? '\n' : '') + foldLine(line, width);
                prevMoreIndented = moreIndented;
              }

              return result;
            }
            function foldLine(line, width) {
              if (line === '' || line[0] === ' ') return line;
              var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.
              var match;
              var start = 0,
                end,
                curr = 0,
                next = 0;
              var result = '';
              while ((match = breakRe.exec(line))) {
                next = match.index;
                if (next - start > width) {
                  end = curr > start ? curr : next; // derive end <= length-2
                  result += '\n' + line.slice(start, end);
                  start = end + 1; // derive start <= length-1
                }
                curr = next;
              }
              result += '\n';
              if (line.length - start > width && curr > start) {
                result += line.slice(start, curr) + '\n' + line.slice(curr + 1);
              } else {
                result += line.slice(start);
              }

              return result.slice(1); // drop extra \n joiner
            }
            function escapeString(string) {
              var result = '';
              var char, nextChar;
              var escapeSeq;

              for (var i = 0; i < string.length; i++) {
                char = string.charCodeAt(i);
                if (char >= 0xd800 && char <= 0xdbff /* high surrogate */) {
                  nextChar = string.charCodeAt(i + 1);
                  if (nextChar >= 0xdc00 && nextChar <= 0xdfff /* low surrogate */) {
                    result += encodeHex((char - 0xd800) * 0x400 + nextChar - 0xdc00 + 0x10000);
                    i++;
                    continue;
                  }
                }
                escapeSeq = ESCAPE_SEQUENCES[char];
                result += !escapeSeq && isPrintable(char) ? string[i] : escapeSeq || encodeHex(char);
              }

              return result;
            }

            function writeFlowSequence(state, level, object) {
              var _result = '',
                _tag = state.tag,
                index,
                length;

              for (index = 0, length = object.length; index < length; index += 1) {
                if (writeNode(state, level, object[index], false, false)) {
                  if (index !== 0) _result += ',' + (!state.condenseFlow ? ' ' : '');
                  _result += state.dump;
                }
              }

              state.tag = _tag;
              state.dump = '[' + _result + ']';
            }

            function writeBlockSequence(state, level, object, compact) {
              var _result = '',
                _tag = state.tag,
                index,
                length;

              for (index = 0, length = object.length; index < length; index += 1) {
                if (writeNode(state, level + 1, object[index], true, true)) {
                  if (!compact || index !== 0) {
                    _result += generateNextLine(state, level);
                  }

                  if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
                    _result += '-';
                  } else {
                    _result += '- ';
                  }

                  _result += state.dump;
                }
              }

              state.tag = _tag;
              state.dump = _result || '[]'; // Empty sequence if no valid values.
            }

            function writeFlowMapping(state, level, object) {
              var _result = '',
                _tag = state.tag,
                objectKeyList = Object.keys(object),
                index,
                length,
                objectKey,
                objectValue,
                pairBuffer;

              for (index = 0, length = objectKeyList.length; index < length; index += 1) {
                pairBuffer = state.condenseFlow ? '"' : '';

                if (index !== 0) pairBuffer += ', ';

                objectKey = objectKeyList[index];
                objectValue = object[objectKey];

                if (!writeNode(state, level, objectKey, false, false)) {
                  continue; // Skip this pair because of invalid key;
                }

                if (state.dump.length > 1024) pairBuffer += '? ';

                pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' ');

                if (!writeNode(state, level, objectValue, false, false)) {
                  continue; // Skip this pair because of invalid value.
                }

                pairBuffer += state.dump;
                _result += pairBuffer;
              }

              state.tag = _tag;
              state.dump = '{' + _result + '}';
            }

            function writeBlockMapping(state, level, object, compact) {
              var _result = '',
                _tag = state.tag,
                objectKeyList = Object.keys(object),
                index,
                length,
                objectKey,
                objectValue,
                explicitPair,
                pairBuffer;
              if (state.sortKeys === true) {
                objectKeyList.sort();
              } else if (typeof state.sortKeys === 'function') {
                objectKeyList.sort(state.sortKeys);
              } else if (state.sortKeys) {
                throw new YAMLException('sortKeys must be a boolean or a function');
              }

              for (index = 0, length = objectKeyList.length; index < length; index += 1) {
                pairBuffer = '';

                if (!compact || index !== 0) {
                  pairBuffer += generateNextLine(state, level);
                }

                objectKey = objectKeyList[index];
                objectValue = object[objectKey];

                if (!writeNode(state, level + 1, objectKey, true, true, true)) {
                  continue; // Skip this pair because of invalid key.
                }

                explicitPair = (state.tag !== null && state.tag !== '?') || (state.dump && state.dump.length > 1024);

                if (explicitPair) {
                  if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
                    pairBuffer += '?';
                  } else {
                    pairBuffer += '? ';
                  }
                }

                pairBuffer += state.dump;

                if (explicitPair) {
                  pairBuffer += generateNextLine(state, level);
                }

                if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
                  continue; // Skip this pair because of invalid value.
                }

                if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
                  pairBuffer += ':';
                } else {
                  pairBuffer += ': ';
                }

                pairBuffer += state.dump;
                _result += pairBuffer;
              }

              state.tag = _tag;
              state.dump = _result || '{}'; // Empty mapping if no valid pairs.
            }

            function detectType(state, object, explicit) {
              var _result, typeList, index, length, type, style;

              typeList = explicit ? state.explicitTypes : state.implicitTypes;

              for (index = 0, length = typeList.length; index < length; index += 1) {
                type = typeList[index];

                if (
                  (type.instanceOf || type.predicate) &&
                  (!type.instanceOf || (typeof object === 'object' && object instanceof type.instanceOf)) &&
                  (!type.predicate || type.predicate(object))
                ) {
                  state.tag = explicit ? type.tag : '?';

                  if (type.represent) {
                    style = state.styleMap[type.tag] || type.defaultStyle;

                    if (_toString.call(type.represent) === '[object Function]') {
                      _result = type.represent(object, style);
                    } else if (_hasOwnProperty.call(type.represent, style)) {
                      _result = type.represent[style](object, style);
                    } else {
                      throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
                    }

                    state.dump = _result;
                  }

                  return true;
                }
              }

              return false;
            }
            function writeNode(state, level, object, block, compact, iskey) {
              state.tag = null;
              state.dump = object;

              if (!detectType(state, object, false)) {
                detectType(state, object, true);
              }

              var type = _toString.call(state.dump);

              if (block) {
                block = state.flowLevel < 0 || state.flowLevel > level;
              }

              var objectOrArray = type === '[object Object]' || type === '[object Array]',
                duplicateIndex,
                duplicate;

              if (objectOrArray) {
                duplicateIndex = state.duplicates.indexOf(object);
                duplicate = duplicateIndex !== -1;
              }

              if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {
                compact = false;
              }

              if (duplicate && state.usedDuplicates[duplicateIndex]) {
                state.dump = '*ref_' + duplicateIndex;
              } else {
                if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
                  state.usedDuplicates[duplicateIndex] = true;
                }
                if (type === '[object Object]') {
                  if (block && Object.keys(state.dump).length !== 0) {
                    writeBlockMapping(state, level, state.dump, compact);
                    if (duplicate) {
                      state.dump = '&ref_' + duplicateIndex + state.dump;
                    }
                  } else {
                    writeFlowMapping(state, level, state.dump);
                    if (duplicate) {
                      state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
                    }
                  }
                } else if (type === '[object Array]') {
                  var arrayLevel = state.noArrayIndent && level > 0 ? level - 1 : level;
                  if (block && state.dump.length !== 0) {
                    writeBlockSequence(state, arrayLevel, state.dump, compact);
                    if (duplicate) {
                      state.dump = '&ref_' + duplicateIndex + state.dump;
                    }
                  } else {
                    writeFlowSequence(state, arrayLevel, state.dump);
                    if (duplicate) {
                      state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
                    }
                  }
                } else if (type === '[object String]') {
                  if (state.tag !== '?') {
                    writeScalar(state, state.dump, level, iskey);
                  }
                } else {
                  if (state.skipInvalid) return false;
                  throw new YAMLException('unacceptable kind of an object to dump ' + type);
                }

                if (state.tag !== null && state.tag !== '?') {
                  state.dump = '!<' + state.tag + '> ' + state.dump;
                }
              }

              return true;
            }

            function getDuplicateReferences(object, state) {
              var objects = [],
                duplicatesIndexes = [],
                index,
                length;

              inspectNode(object, objects, duplicatesIndexes);

              for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
                state.duplicates.push(objects[duplicatesIndexes[index]]);
              }
              state.usedDuplicates = new Array(length);
            }

            function inspectNode(object, objects, duplicatesIndexes) {
              var objectKeyList, index, length;

              if (object !== null && typeof object === 'object') {
                index = objects.indexOf(object);
                if (index !== -1) {
                  if (duplicatesIndexes.indexOf(index) === -1) {
                    duplicatesIndexes.push(index);
                  }
                } else {
                  objects.push(object);

                  if (Array.isArray(object)) {
                    for (index = 0, length = object.length; index < length; index += 1) {
                      inspectNode(object[index], objects, duplicatesIndexes);
                    }
                  } else {
                    objectKeyList = Object.keys(object);

                    for (index = 0, length = objectKeyList.length; index < length; index += 1) {
                      inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
                    }
                  }
                }
              }
            }

            function dump(input, options) {
              options = options || {};

              var state = new State(options);

              if (!state.noRefs) getDuplicateReferences(input, state);

              if (writeNode(state, 0, input, true, true)) return state.dump + '\n';

              return '';
            }

            function safeDump(input, options) {
              return dump(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
            }

            module.exports.dump = dump;
            module.exports.safeDump = safeDump;
          },
          { './common': 5, './exception': 7, './schema/default_full': 12, './schema/default_safe': 13 },
        ],
        7: [
          function (require, module, exports) {
            'use strict';

            function YAMLException(reason, mark) {
              Error.call(this);

              this.name = 'YAMLException';
              this.reason = reason;
              this.mark = mark;
              this.message = (this.reason || '(unknown reason)') + (this.mark ? ' ' + this.mark.toString() : '');
              if (Error.captureStackTrace) {
                Error.captureStackTrace(this, this.constructor);
              } else {
                this.stack = new Error().stack || '';
              }
            }
            YAMLException.prototype = Object.create(Error.prototype);
            YAMLException.prototype.constructor = YAMLException;

            YAMLException.prototype.toString = function toString(compact) {
              var result = this.name + ': ';

              result += this.reason || '(unknown reason)';

              if (!compact && this.mark) {
                result += ' ' + this.mark.toString();
              }

              return result;
            };

            module.exports = YAMLException;
          },
          {},
        ],
        8: [
          function (require, module, exports) {
            'use strict';

            var common = require('./common');
            var YAMLException = require('./exception');
            var Mark = require('./mark');
            var DEFAULT_SAFE_SCHEMA = require('./schema/default_safe');
            var DEFAULT_FULL_SCHEMA = require('./schema/default_full');

            var _hasOwnProperty = Object.prototype.hasOwnProperty;

            var CONTEXT_FLOW_IN = 1;
            var CONTEXT_FLOW_OUT = 2;
            var CONTEXT_BLOCK_IN = 3;
            var CONTEXT_BLOCK_OUT = 4;

            var CHOMPING_CLIP = 1;
            var CHOMPING_STRIP = 2;
            var CHOMPING_KEEP = 3;

            var PATTERN_NON_PRINTABLE =
              /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
            var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
            var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
            var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
            var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;

            function is_EOL(c) {
              return c === 0x0a /* LF */ || c === 0x0d /* CR */;
            }

            function is_WHITE_SPACE(c) {
              return c === 0x09 /* Tab */ || c === 0x20 /* Space */;
            }

            function is_WS_OR_EOL(c) {
              return c === 0x09 /* Tab */ || c === 0x20 /* Space */ || c === 0x0a /* LF */ || c === 0x0d /* CR */;
            }

            function is_FLOW_INDICATOR(c) {
              return (
                c === 0x2c /* , */ ||
                c === 0x5b /* [ */ ||
                c === 0x5d /* ] */ ||
                c === 0x7b /* { */ ||
                c === 0x7d /* } */
              );
            }

            function fromHexCode(c) {
              var lc;

              if (c /* 0 */ >= 0x30 && c <= 0x39 /* 9 */) {
                return c - 0x30;
              }
              lc = c | 0x20;

              if (lc /* a */ >= 0x61 && lc <= 0x66 /* f */) {
                return lc - 0x61 + 10;
              }

              return -1;
            }

            function escapedHexLen(c) {
              if (c === 0x78 /* x */) {
                return 2;
              }
              if (c === 0x75 /* u */) {
                return 4;
              }
              if (c === 0x55 /* U */) {
                return 8;
              }
              return 0;
            }

            function fromDecimalCode(c) {
              if (c /* 0 */ >= 0x30 && c <= 0x39 /* 9 */) {
                return c - 0x30;
              }

              return -1;
            }

            function simpleEscapeSequence(c) {
              return c === 0x30 /* 0 */
                ? '\x00'
                : c === 0x61 /* a */
                ? '\x07'
                : c === 0x62 /* b */
                ? '\x08'
                : c === 0x74 /* t */
                ? '\x09'
                : c === 0x09 /* Tab */
                ? '\x09'
                : c === 0x6e /* n */
                ? '\x0A'
                : c === 0x76 /* v */
                ? '\x0B'
                : c === 0x66 /* f */
                ? '\x0C'
                : c === 0x72 /* r */
                ? '\x0D'
                : c === 0x65 /* e */
                ? '\x1B'
                : c === 0x20 /* Space */
                ? ' '
                : c === 0x22 /* " */
                ? '\x22'
                : c === 0x2f /* / */
                ? '/'
                : c === 0x5c /* \ */
                ? '\x5C'
                : c === 0x4e /* N */
                ? '\x85'
                : c === 0x5f /* _ */
                ? '\xA0'
                : c === 0x4c /* L */
                ? '\u2028'
                : c === 0x50 /* P */
                ? '\u2029'
                : '';
            }

            function charFromCodepoint(c) {
              if (c <= 0xffff) {
                return String.fromCharCode(c);
              }
              return String.fromCharCode(((c - 0x010000) >> 10) + 0xd800, ((c - 0x010000) & 0x03ff) + 0xdc00);
            }

            var simpleEscapeCheck = new Array(256); // integer, for fast access
            var simpleEscapeMap = new Array(256);
            for (var i = 0; i < 256; i++) {
              simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
              simpleEscapeMap[i] = simpleEscapeSequence(i);
            }

            function State(input, options) {
              this.input = input;

              this.filename = options['filename'] || null;
              this.schema = options['schema'] || DEFAULT_FULL_SCHEMA;
              this.onWarning = options['onWarning'] || null;
              this.legacy = options['legacy'] || false;
              this.json = options['json'] || false;
              this.listener = options['listener'] || null;

              this.implicitTypes = this.schema.compiledImplicit;
              this.typeMap = this.schema.compiledTypeMap;

              this.length = input.length;
              this.position = 0;
              this.line = 0;
              this.lineStart = 0;
              this.lineIndent = 0;

              this.documents = [];
            }

            function generateError(state, message) {
              return new YAMLException(
                message,
                new Mark(state.filename, state.input, state.position, state.line, state.position - state.lineStart),
              );
            }

            function throwError(state, message) {
              throw generateError(state, message);
            }

            function throwWarning(state, message) {
              if (state.onWarning) {
                state.onWarning.call(null, generateError(state, message));
              }
            }

            var directiveHandlers = {
              YAML: function handleYamlDirective(state, name, args) {
                var match, major, minor;

                if (state.version !== null) {
                  throwError(state, 'duplication of %YAML directive');
                }

                if (args.length !== 1) {
                  throwError(state, 'YAML directive accepts exactly one argument');
                }

                match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);

                if (match === null) {
                  throwError(state, 'ill-formed argument of the YAML directive');
                }

                major = parseInt(match[1], 10);
                minor = parseInt(match[2], 10);

                if (major !== 1) {
                  throwError(state, 'unacceptable YAML version of the document');
                }

                state.version = args[0];
                state.checkLineBreaks = minor < 2;

                if (minor !== 1 && minor !== 2) {
                  throwWarning(state, 'unsupported YAML version of the document');
                }
              },

              TAG: function handleTagDirective(state, name, args) {
                var handle, prefix;

                if (args.length !== 2) {
                  throwError(state, 'TAG directive accepts exactly two arguments');
                }

                handle = args[0];
                prefix = args[1];

                if (!PATTERN_TAG_HANDLE.test(handle)) {
                  throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');
                }

                if (_hasOwnProperty.call(state.tagMap, handle)) {
                  throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
                }

                if (!PATTERN_TAG_URI.test(prefix)) {
                  throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive');
                }

                state.tagMap[handle] = prefix;
              },
            };

            function captureSegment(state, start, end, checkJson) {
              var _position, _length, _character, _result;

              if (start < end) {
                _result = state.input.slice(start, end);

                if (checkJson) {
                  for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
                    _character = _result.charCodeAt(_position);
                    if (!(_character === 0x09 || (_character >= 0x20 && _character <= 0x10ffff))) {
                      throwError(state, 'expected valid JSON character');
                    }
                  }
                } else if (PATTERN_NON_PRINTABLE.test(_result)) {
                  throwError(state, 'the stream contains non-printable characters');
                }

                state.result += _result;
              }
            }

            function mergeMappings(state, destination, source, overridableKeys) {
              var sourceKeys, key, index, quantity;

              if (!common.isObject(source)) {
                throwError(state, 'cannot merge mappings; the provided source object is unacceptable');
              }

              sourceKeys = Object.keys(source);

              for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
                key = sourceKeys[index];

                if (!_hasOwnProperty.call(destination, key)) {
                  destination[key] = source[key];
                  overridableKeys[key] = true;
                }
              }
            }

            function storeMappingPair(
              state,
              _result,
              overridableKeys,
              keyTag,
              keyNode,
              valueNode,
              startLine,
              startPos,
            ) {
              var index, quantity;

              keyNode = String(keyNode);

              if (_result === null) {
                _result = {};
              }

              if (keyTag === 'tag:yaml.org,2002:merge') {
                if (Array.isArray(valueNode)) {
                  for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
                    mergeMappings(state, _result, valueNode[index], overridableKeys);
                  }
                } else {
                  mergeMappings(state, _result, valueNode, overridableKeys);
                }
              } else {
                if (
                  !state.json &&
                  !_hasOwnProperty.call(overridableKeys, keyNode) &&
                  _hasOwnProperty.call(_result, keyNode)
                ) {
                  state.line = startLine || state.line;
                  state.position = startPos || state.position;
                  throwError(state, 'duplicated mapping key');
                }
                _result[keyNode] = valueNode;
                delete overridableKeys[keyNode];
              }

              return _result;
            }

            function readLineBreak(state) {
              var ch;

              ch = state.input.charCodeAt(state.position);

              if (ch === 0x0a /* LF */) {
                state.position++;
              } else if (ch === 0x0d /* CR */) {
                state.position++;
                if (state.input.charCodeAt(state.position) === 0x0a /* LF */) {
                  state.position++;
                }
              } else {
                throwError(state, 'a line break is expected');
              }

              state.line += 1;
              state.lineStart = state.position;
            }

            function skipSeparationSpace(state, allowComments, checkIndent) {
              var lineBreaks = 0,
                ch = state.input.charCodeAt(state.position);

              while (ch !== 0) {
                while (is_WHITE_SPACE(ch)) {
                  ch = state.input.charCodeAt(++state.position);
                }

                if (allowComments && ch === 0x23 /* # */) {
                  do {
                    ch = state.input.charCodeAt(++state.position);
                  } while (ch !== 0x0a /* LF */ && ch !== 0x0d /* CR */ && ch !== 0);
                }

                if (is_EOL(ch)) {
                  readLineBreak(state);

                  ch = state.input.charCodeAt(state.position);
                  lineBreaks++;
                  state.lineIndent = 0;

                  while (ch === 0x20 /* Space */) {
                    state.lineIndent++;
                    ch = state.input.charCodeAt(++state.position);
                  }
                } else {
                  break;
                }
              }

              if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
                throwWarning(state, 'deficient indentation');
              }

              return lineBreaks;
            }

            function testDocumentSeparator(state) {
              var _position = state.position,
                ch;

              ch = state.input.charCodeAt(_position);
              if (
                (ch === 0x2d /* - */ || ch === 0x2e) /* . */ &&
                ch === state.input.charCodeAt(_position + 1) &&
                ch === state.input.charCodeAt(_position + 2)
              ) {
                _position += 3;

                ch = state.input.charCodeAt(_position);

                if (ch === 0 || is_WS_OR_EOL(ch)) {
                  return true;
                }
              }

              return false;
            }

            function writeFoldedLines(state, count) {
              if (count === 1) {
                state.result += ' ';
              } else if (count > 1) {
                state.result += common.repeat('\n', count - 1);
              }
            }

            function readPlainScalar(state, nodeIndent, withinFlowCollection) {
              var preceding,
                following,
                captureStart,
                captureEnd,
                hasPendingContent,
                _line,
                _lineStart,
                _lineIndent,
                _kind = state.kind,
                _result = state.result,
                ch;

              ch = state.input.charCodeAt(state.position);

              if (
                is_WS_OR_EOL(ch) ||
                is_FLOW_INDICATOR(ch) ||
                ch === 0x23 /* # */ ||
                ch === 0x26 /* & */ ||
                ch === 0x2a /* * */ ||
                ch === 0x21 /* ! */ ||
                ch === 0x7c /* | */ ||
                ch === 0x3e /* > */ ||
                ch === 0x27 /* ' */ ||
                ch === 0x22 /* " */ ||
                ch === 0x25 /* % */ ||
                ch === 0x40 /* @ */ ||
                ch === 0x60 /* ` */
              ) {
                return false;
              }

              if (ch === 0x3f /* ? */ || ch === 0x2d /* - */) {
                following = state.input.charCodeAt(state.position + 1);

                if (is_WS_OR_EOL(following) || (withinFlowCollection && is_FLOW_INDICATOR(following))) {
                  return false;
                }
              }

              state.kind = 'scalar';
              state.result = '';
              captureStart = captureEnd = state.position;
              hasPendingContent = false;

              while (ch !== 0) {
                if (ch === 0x3a /* : */) {
                  following = state.input.charCodeAt(state.position + 1);

                  if (is_WS_OR_EOL(following) || (withinFlowCollection && is_FLOW_INDICATOR(following))) {
                    break;
                  }
                } else if (ch === 0x23 /* # */) {
                  preceding = state.input.charCodeAt(state.position - 1);

                  if (is_WS_OR_EOL(preceding)) {
                    break;
                  }
                } else if (
                  (state.position === state.lineStart && testDocumentSeparator(state)) ||
                  (withinFlowCollection && is_FLOW_INDICATOR(ch))
                ) {
                  break;
                } else if (is_EOL(ch)) {
                  _line = state.line;
                  _lineStart = state.lineStart;
                  _lineIndent = state.lineIndent;
                  skipSeparationSpace(state, false, -1);

                  if (state.lineIndent >= nodeIndent) {
                    hasPendingContent = true;
                    ch = state.input.charCodeAt(state.position);
                    continue;
                  } else {
                    state.position = captureEnd;
                    state.line = _line;
                    state.lineStart = _lineStart;
                    state.lineIndent = _lineIndent;
                    break;
                  }
                }

                if (hasPendingContent) {
                  captureSegment(state, captureStart, captureEnd, false);
                  writeFoldedLines(state, state.line - _line);
                  captureStart = captureEnd = state.position;
                  hasPendingContent = false;
                }

                if (!is_WHITE_SPACE(ch)) {
                  captureEnd = state.position + 1;
                }

                ch = state.input.charCodeAt(++state.position);
              }

              captureSegment(state, captureStart, captureEnd, false);

              if (state.result) {
                return true;
              }

              state.kind = _kind;
              state.result = _result;
              return false;
            }

            function readSingleQuotedScalar(state, nodeIndent) {
              var ch, captureStart, captureEnd;

              ch = state.input.charCodeAt(state.position);

              if (ch !== 0x27 /* ' */) {
                return false;
              }

              state.kind = 'scalar';
              state.result = '';
              state.position++;
              captureStart = captureEnd = state.position;

              while ((ch = state.input.charCodeAt(state.position)) !== 0) {
                if (ch === 0x27 /* ' */) {
                  captureSegment(state, captureStart, state.position, true);
                  ch = state.input.charCodeAt(++state.position);

                  if (ch === 0x27 /* ' */) {
                    captureStart = state.position;
                    state.position++;
                    captureEnd = state.position;
                  } else {
                    return true;
                  }
                } else if (is_EOL(ch)) {
                  captureSegment(state, captureStart, captureEnd, true);
                  writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
                  captureStart = captureEnd = state.position;
                } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
                  throwError(state, 'unexpected end of the document within a single quoted scalar');
                } else {
                  state.position++;
                  captureEnd = state.position;
                }
              }

              throwError(state, 'unexpected end of the stream within a single quoted scalar');
            }

            function readDoubleQuotedScalar(state, nodeIndent) {
              var captureStart, captureEnd, hexLength, hexResult, tmp, ch;

              ch = state.input.charCodeAt(state.position);

              if (ch !== 0x22 /* " */) {
                return false;
              }

              state.kind = 'scalar';
              state.result = '';
              state.position++;
              captureStart = captureEnd = state.position;

              while ((ch = state.input.charCodeAt(state.position)) !== 0) {
                if (ch === 0x22 /* " */) {
                  captureSegment(state, captureStart, state.position, true);
                  state.position++;
                  return true;
                } else if (ch === 0x5c /* \ */) {
                  captureSegment(state, captureStart, state.position, true);
                  ch = state.input.charCodeAt(++state.position);

                  if (is_EOL(ch)) {
                    skipSeparationSpace(state, false, nodeIndent);
                  } else if (ch < 256 && simpleEscapeCheck[ch]) {
                    state.result += simpleEscapeMap[ch];
                    state.position++;
                  } else if ((tmp = escapedHexLen(ch)) > 0) {
                    hexLength = tmp;
                    hexResult = 0;

                    for (; hexLength > 0; hexLength--) {
                      ch = state.input.charCodeAt(++state.position);

                      if ((tmp = fromHexCode(ch)) >= 0) {
                        hexResult = (hexResult << 4) + tmp;
                      } else {
                        throwError(state, 'expected hexadecimal character');
                      }
                    }

                    state.result += charFromCodepoint(hexResult);

                    state.position++;
                  } else {
                    throwError(state, 'unknown escape sequence');
                  }

                  captureStart = captureEnd = state.position;
                } else if (is_EOL(ch)) {
                  captureSegment(state, captureStart, captureEnd, true);
                  writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
                  captureStart = captureEnd = state.position;
                } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
                  throwError(state, 'unexpected end of the document within a double quoted scalar');
                } else {
                  state.position++;
                  captureEnd = state.position;
                }
              }

              throwError(state, 'unexpected end of the stream within a double quoted scalar');
            }

            function readFlowCollection(state, nodeIndent) {
              var readNext = true,
                _line,
                _tag = state.tag,
                _result,
                _anchor = state.anchor,
                following,
                terminator,
                isPair,
                isExplicitPair,
                isMapping,
                overridableKeys = {},
                keyNode,
                keyTag,
                valueNode,
                ch;

              ch = state.input.charCodeAt(state.position);

              if (ch === 0x5b /* [ */) {
                terminator = 0x5d;
                isMapping = false;
                _result = [];
              } else if (ch === 0x7b /* { */) {
                terminator = 0x7d;
                isMapping = true;
                _result = {};
              } else {
                return false;
              }

              if (state.anchor !== null) {
                state.anchorMap[state.anchor] = _result;
              }

              ch = state.input.charCodeAt(++state.position);

              while (ch !== 0) {
                skipSeparationSpace(state, true, nodeIndent);

                ch = state.input.charCodeAt(state.position);

                if (ch === terminator) {
                  state.position++;
                  state.tag = _tag;
                  state.anchor = _anchor;
                  state.kind = isMapping ? 'mapping' : 'sequence';
                  state.result = _result;
                  return true;
                } else if (!readNext) {
                  throwError(state, 'missed comma between flow collection entries');
                }

                keyTag = keyNode = valueNode = null;
                isPair = isExplicitPair = false;

                if (ch === 0x3f /* ? */) {
                  following = state.input.charCodeAt(state.position + 1);

                  if (is_WS_OR_EOL(following)) {
                    isPair = isExplicitPair = true;
                    state.position++;
                    skipSeparationSpace(state, true, nodeIndent);
                  }
                }

                _line = state.line;
                composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
                keyTag = state.tag;
                keyNode = state.result;
                skipSeparationSpace(state, true, nodeIndent);

                ch = state.input.charCodeAt(state.position);

                if ((isExplicitPair || state.line === _line) && ch === 0x3a /* : */) {
                  isPair = true;
                  ch = state.input.charCodeAt(++state.position);
                  skipSeparationSpace(state, true, nodeIndent);
                  composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
                  valueNode = state.result;
                }

                if (isMapping) {
                  storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode);
                } else if (isPair) {
                  _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode));
                } else {
                  _result.push(keyNode);
                }

                skipSeparationSpace(state, true, nodeIndent);

                ch = state.input.charCodeAt(state.position);

                if (ch === 0x2c /* , */) {
                  readNext = true;
                  ch = state.input.charCodeAt(++state.position);
                } else {
                  readNext = false;
                }
              }

              throwError(state, 'unexpected end of the stream within a flow collection');
            }

            function readBlockScalar(state, nodeIndent) {
              var captureStart,
                folding,
                chomping = CHOMPING_CLIP,
                didReadContent = false,
                detectedIndent = false,
                textIndent = nodeIndent,
                emptyLines = 0,
                atMoreIndented = false,
                tmp,
                ch;

              ch = state.input.charCodeAt(state.position);

              if (ch === 0x7c /* | */) {
                folding = false;
              } else if (ch === 0x3e /* > */) {
                folding = true;
              } else {
                return false;
              }

              state.kind = 'scalar';
              state.result = '';

              while (ch !== 0) {
                ch = state.input.charCodeAt(++state.position);

                if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {
                  if (CHOMPING_CLIP === chomping) {
                    chomping = ch === 0x2b /* + */ ? CHOMPING_KEEP : CHOMPING_STRIP;
                  } else {
                    throwError(state, 'repeat of a chomping mode identifier');
                  }
                } else if ((tmp = fromDecimalCode(ch)) >= 0) {
                  if (tmp === 0) {
                    throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');
                  } else if (!detectedIndent) {
                    textIndent = nodeIndent + tmp - 1;
                    detectedIndent = true;
                  } else {
                    throwError(state, 'repeat of an indentation width identifier');
                  }
                } else {
                  break;
                }
              }

              if (is_WHITE_SPACE(ch)) {
                do {
                  ch = state.input.charCodeAt(++state.position);
                } while (is_WHITE_SPACE(ch));

                if (ch === 0x23 /* # */) {
                  do {
                    ch = state.input.charCodeAt(++state.position);
                  } while (!is_EOL(ch) && ch !== 0);
                }
              }

              while (ch !== 0) {
                readLineBreak(state);
                state.lineIndent = 0;

                ch = state.input.charCodeAt(state.position);

                while ((!detectedIndent || state.lineIndent < textIndent) && ch === 0x20 /* Space */) {
                  state.lineIndent++;
                  ch = state.input.charCodeAt(++state.position);
                }

                if (!detectedIndent && state.lineIndent > textIndent) {
                  textIndent = state.lineIndent;
                }

                if (is_EOL(ch)) {
                  emptyLines++;
                  continue;
                }
                if (state.lineIndent < textIndent) {
                  if (chomping === CHOMPING_KEEP) {
                    state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
                  } else if (chomping === CHOMPING_CLIP) {
                    if (didReadContent) {
                      // i.e. only if the scalar is not empty.
                      state.result += '\n';
                    }
                  }
                  break;
                }
                if (folding) {
                  if (is_WHITE_SPACE(ch)) {
                    atMoreIndented = true;
                    state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
                  } else if (atMoreIndented) {
                    atMoreIndented = false;
                    state.result += common.repeat('\n', emptyLines + 1);
                  } else if (emptyLines === 0) {
                    if (didReadContent) {
                      // i.e. only if we have already read some scalar content.
                      state.result += ' ';
                    }
                  } else {
                    state.result += common.repeat('\n', emptyLines);
                  }
                } else {
                  state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
                }

                didReadContent = true;
                detectedIndent = true;
                emptyLines = 0;
                captureStart = state.position;

                while (!is_EOL(ch) && ch !== 0) {
                  ch = state.input.charCodeAt(++state.position);
                }

                captureSegment(state, captureStart, state.position, false);
              }

              return true;
            }

            function readBlockSequence(state, nodeIndent) {
              var _line,
                _tag = state.tag,
                _anchor = state.anchor,
                _result = [],
                following,
                detected = false,
                ch;

              if (state.anchor !== null) {
                state.anchorMap[state.anchor] = _result;
              }

              ch = state.input.charCodeAt(state.position);

              while (ch !== 0) {
                if (ch !== 0x2d /* - */) {
                  break;
                }

                following = state.input.charCodeAt(state.position + 1);

                if (!is_WS_OR_EOL(following)) {
                  break;
                }

                detected = true;
                state.position++;

                if (skipSeparationSpace(state, true, -1)) {
                  if (state.lineIndent <= nodeIndent) {
                    _result.push(null);
                    ch = state.input.charCodeAt(state.position);
                    continue;
                  }
                }

                _line = state.line;
                composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
                _result.push(state.result);
                skipSeparationSpace(state, true, -1);

                ch = state.input.charCodeAt(state.position);

                if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) {
                  throwError(state, 'bad indentation of a sequence entry');
                } else if (state.lineIndent < nodeIndent) {
                  break;
                }
              }

              if (detected) {
                state.tag = _tag;
                state.anchor = _anchor;
                state.kind = 'sequence';
                state.result = _result;
                return true;
              }
              return false;
            }

            function readBlockMapping(state, nodeIndent, flowIndent) {
              var following,
                allowCompact,
                _line,
                _pos,
                _tag = state.tag,
                _anchor = state.anchor,
                _result = {},
                overridableKeys = {},
                keyTag = null,
                keyNode = null,
                valueNode = null,
                atExplicitKey = false,
                detected = false,
                ch;

              if (state.anchor !== null) {
                state.anchorMap[state.anchor] = _result;
              }

              ch = state.input.charCodeAt(state.position);

              while (ch !== 0) {
                following = state.input.charCodeAt(state.position + 1);
                _line = state.line; // Save the current line.
                _pos = state.position;
                if ((ch === 0x3f /* ? */ || ch === 0x3a /*: */) && is_WS_OR_EOL(following)) {
                  if (ch === 0x3f /* ? */) {
                    if (atExplicitKey) {
                      storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
                      keyTag = keyNode = valueNode = null;
                    }

                    detected = true;
                    atExplicitKey = true;
                    allowCompact = true;
                  } else if (atExplicitKey) {
                    atExplicitKey = false;
                    allowCompact = true;
                  } else {
                    throwError(
                      state,
                      'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line',
                    );
                  }

                  state.position += 1;
                  ch = following;
                } else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
                  if (state.line === _line) {
                    ch = state.input.charCodeAt(state.position);

                    while (is_WHITE_SPACE(ch)) {
                      ch = state.input.charCodeAt(++state.position);
                    }

                    if (ch === 0x3a /* : */) {
                      ch = state.input.charCodeAt(++state.position);

                      if (!is_WS_OR_EOL(ch)) {
                        throwError(
                          state,
                          'a whitespace character is expected after the key-value separator within a block mapping',
                        );
                      }

                      if (atExplicitKey) {
                        storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
                        keyTag = keyNode = valueNode = null;
                      }

                      detected = true;
                      atExplicitKey = false;
                      allowCompact = false;
                      keyTag = state.tag;
                      keyNode = state.result;
                    } else if (detected) {
                      throwError(state, 'can not read an implicit mapping pair; a colon is missed');
                    } else {
                      state.tag = _tag;
                      state.anchor = _anchor;
                      return true; // Keep the result of `composeNode`.
                    }
                  } else if (detected) {
                    throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');
                  } else {
                    state.tag = _tag;
                    state.anchor = _anchor;
                    return true; // Keep the result of `composeNode`.
                  }
                } else {
                  break; // Reading is done. Go to the epilogue.
                }
                if (state.line === _line || state.lineIndent > nodeIndent) {
                  if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
                    if (atExplicitKey) {
                      keyNode = state.result;
                    } else {
                      valueNode = state.result;
                    }
                  }

                  if (!atExplicitKey) {
                    storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos);
                    keyTag = keyNode = valueNode = null;
                  }

                  skipSeparationSpace(state, true, -1);
                  ch = state.input.charCodeAt(state.position);
                }

                if (state.lineIndent > nodeIndent && ch !== 0) {
                  throwError(state, 'bad indentation of a mapping entry');
                } else if (state.lineIndent < nodeIndent) {
                  break;
                }
              }
              if (atExplicitKey) {
                storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
              }
              if (detected) {
                state.tag = _tag;
                state.anchor = _anchor;
                state.kind = 'mapping';
                state.result = _result;
              }

              return detected;
            }

            function readTagProperty(state) {
              var _position,
                isVerbatim = false,
                isNamed = false,
                tagHandle,
                tagName,
                ch;

              ch = state.input.charCodeAt(state.position);

              if (ch !== 0x21 /* ! */) return false;

              if (state.tag !== null) {
                throwError(state, 'duplication of a tag property');
              }

              ch = state.input.charCodeAt(++state.position);

              if (ch === 0x3c /* < */) {
                isVerbatim = true;
                ch = state.input.charCodeAt(++state.position);
              } else if (ch === 0x21 /* ! */) {
                isNamed = true;
                tagHandle = '!!';
                ch = state.input.charCodeAt(++state.position);
              } else {
                tagHandle = '!';
              }

              _position = state.position;

              if (isVerbatim) {
                do {
                  ch = state.input.charCodeAt(++state.position);
                } while (ch !== 0 && ch !== 0x3e /* > */);

                if (state.position < state.length) {
                  tagName = state.input.slice(_position, state.position);
                  ch = state.input.charCodeAt(++state.position);
                } else {
                  throwError(state, 'unexpected end of the stream within a verbatim tag');
                }
              } else {
                while (ch !== 0 && !is_WS_OR_EOL(ch)) {
                  if (ch === 0x21 /* ! */) {
                    if (!isNamed) {
                      tagHandle = state.input.slice(_position - 1, state.position + 1);

                      if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
                        throwError(state, 'named tag handle cannot contain such characters');
                      }

                      isNamed = true;
                      _position = state.position + 1;
                    } else {
                      throwError(state, 'tag suffix cannot contain exclamation marks');
                    }
                  }

                  ch = state.input.charCodeAt(++state.position);
                }

                tagName = state.input.slice(_position, state.position);

                if (PATTERN_FLOW_INDICATORS.test(tagName)) {
                  throwError(state, 'tag suffix cannot contain flow indicator characters');
                }
              }

              if (tagName && !PATTERN_TAG_URI.test(tagName)) {
                throwError(state, 'tag name cannot contain such characters: ' + tagName);
              }

              if (isVerbatim) {
                state.tag = tagName;
              } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
                state.tag = state.tagMap[tagHandle] + tagName;
              } else if (tagHandle === '!') {
                state.tag = '!' + tagName;
              } else if (tagHandle === '!!') {
                state.tag = 'tag:yaml.org,2002:' + tagName;
              } else {
                throwError(state, 'undeclared tag handle "' + tagHandle + '"');
              }

              return true;
            }

            function readAnchorProperty(state) {
              var _position, ch;

              ch = state.input.charCodeAt(state.position);

              if (ch !== 0x26 /* & */) return false;

              if (state.anchor !== null) {
                throwError(state, 'duplication of an anchor property');
              }

              ch = state.input.charCodeAt(++state.position);
              _position = state.position;

              while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
                ch = state.input.charCodeAt(++state.position);
              }

              if (state.position === _position) {
                throwError(state, 'name of an anchor node must contain at least one character');
              }

              state.anchor = state.input.slice(_position, state.position);
              return true;
            }

            function readAlias(state) {
              var _position, alias, ch;

              ch = state.input.charCodeAt(state.position);

              if (ch !== 0x2a /* * */) return false;

              ch = state.input.charCodeAt(++state.position);
              _position = state.position;

              while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
                ch = state.input.charCodeAt(++state.position);
              }

              if (state.position === _position) {
                throwError(state, 'name of an alias node must contain at least one character');
              }

              alias = state.input.slice(_position, state.position);

              if (!state.anchorMap.hasOwnProperty(alias)) {
                throwError(state, 'unidentified alias "' + alias + '"');
              }

              state.result = state.anchorMap[alias];
              skipSeparationSpace(state, true, -1);
              return true;
            }

            function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
              var allowBlockStyles,
                allowBlockScalars,
                allowBlockCollections,
                indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this<parent
                atNewLine = false,
                hasContent = false,
                typeIndex,
                typeQuantity,
                type,
                flowIndent,
                blockIndent;

              if (state.listener !== null) {
                state.listener('open', state);
              }

              state.tag = null;
              state.anchor = null;
              state.kind = null;
              state.result = null;

              allowBlockStyles =
                allowBlockScalars =
                allowBlockCollections =
                  CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;

              if (allowToSeek) {
                if (skipSeparationSpace(state, true, -1)) {
                  atNewLine = true;

                  if (state.lineIndent > parentIndent) {
                    indentStatus = 1;
                  } else if (state.lineIndent === parentIndent) {
                    indentStatus = 0;
                  } else if (state.lineIndent < parentIndent) {
                    indentStatus = -1;
                  }
                }
              }

              if (indentStatus === 1) {
                while (readTagProperty(state) || readAnchorProperty(state)) {
                  if (skipSeparationSpace(state, true, -1)) {
                    atNewLine = true;
                    allowBlockCollections = allowBlockStyles;

                    if (state.lineIndent > parentIndent) {
                      indentStatus = 1;
                    } else if (state.lineIndent === parentIndent) {
                      indentStatus = 0;
                    } else if (state.lineIndent < parentIndent) {
                      indentStatus = -1;
                    }
                  } else {
                    allowBlockCollections = false;
                  }
                }
              }

              if (allowBlockCollections) {
                allowBlockCollections = atNewLine || allowCompact;
              }

              if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
                if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
                  flowIndent = parentIndent;
                } else {
                  flowIndent = parentIndent + 1;
                }

                blockIndent = state.position - state.lineStart;

                if (indentStatus === 1) {
                  if (
                    (allowBlockCollections &&
                      (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent))) ||
                    readFlowCollection(state, flowIndent)
                  ) {
                    hasContent = true;
                  } else {
                    if (
                      (allowBlockScalars && readBlockScalar(state, flowIndent)) ||
                      readSingleQuotedScalar(state, flowIndent) ||
                      readDoubleQuotedScalar(state, flowIndent)
                    ) {
                      hasContent = true;
                    } else if (readAlias(state)) {
                      hasContent = true;

                      if (state.tag !== null || state.anchor !== null) {
                        throwError(state, 'alias node should not have any properties');
                      }
                    } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
                      hasContent = true;

                      if (state.tag === null) {
                        state.tag = '?';
                      }
                    }

                    if (state.anchor !== null) {
                      state.anchorMap[state.anchor] = state.result;
                    }
                  }
                } else if (indentStatus === 0) {
                  hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
                }
              }

              if (state.tag !== null && state.tag !== '!') {
                if (state.tag === '?') {
                  for (
                    typeIndex = 0, typeQuantity = state.implicitTypes.length;
                    typeIndex < typeQuantity;
                    typeIndex += 1
                  ) {
                    type = state.implicitTypes[typeIndex];

                    if (type.resolve(state.result)) {
                      // `state.result` updated in resolver if matched
                      state.result = type.construct(state.result);
                      state.tag = type.tag;
                      if (state.anchor !== null) {
                        state.anchorMap[state.anchor] = state.result;
                      }
                      break;
                    }
                  }
                } else if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
                  type = state.typeMap[state.kind || 'fallback'][state.tag];

                  if (state.result !== null && type.kind !== state.kind) {
                    throwError(
                      state,
                      'unacceptable node kind for !<' +
                        state.tag +
                        '> tag; it should be "' +
                        type.kind +
                        '", not "' +
                        state.kind +
                        '"',
                    );
                  }

                  if (!type.resolve(state.result)) {
                    // `state.result` updated in resolver if matched
                    throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');
                  } else {
                    state.result = type.construct(state.result);
                    if (state.anchor !== null) {
                      state.anchorMap[state.anchor] = state.result;
                    }
                  }
                } else {
                  throwError(state, 'unknown tag !<' + state.tag + '>');
                }
              }

              if (state.listener !== null) {
                state.listener('close', state);
              }
              return state.tag !== null || state.anchor !== null || hasContent;
            }

            function readDocument(state) {
              var documentStart = state.position,
                _position,
                directiveName,
                directiveArgs,
                hasDirectives = false,
                ch;

              state.version = null;
              state.checkLineBreaks = state.legacy;
              state.tagMap = {};
              state.anchorMap = {};

              while ((ch = state.input.charCodeAt(state.position)) !== 0) {
                skipSeparationSpace(state, true, -1);

                ch = state.input.charCodeAt(state.position);

                if (state.lineIndent > 0 || ch !== 0x25 /* % */) {
                  break;
                }

                hasDirectives = true;
                ch = state.input.charCodeAt(++state.position);
                _position = state.position;

                while (ch !== 0 && !is_WS_OR_EOL(ch)) {
                  ch = state.input.charCodeAt(++state.position);
                }

                directiveName = state.input.slice(_position, state.position);
                directiveArgs = [];

                if (directiveName.length < 1) {
                  throwError(state, 'directive name must not be less than one character in length');
                }

                while (ch !== 0) {
                  while (is_WHITE_SPACE(ch)) {
                    ch = state.input.charCodeAt(++state.position);
                  }

                  if (ch === 0x23 /* # */) {
                    do {
                      ch = state.input.charCodeAt(++state.position);
                    } while (ch !== 0 && !is_EOL(ch));
                    break;
                  }

                  if (is_EOL(ch)) break;

                  _position = state.position;

                  while (ch !== 0 && !is_WS_OR_EOL(ch)) {
                    ch = state.input.charCodeAt(++state.position);
                  }

                  directiveArgs.push(state.input.slice(_position, state.position));
                }

                if (ch !== 0) readLineBreak(state);

                if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
                  directiveHandlers[directiveName](state, directiveName, directiveArgs);
                } else {
                  throwWarning(state, 'unknown document directive "' + directiveName + '"');
                }
              }

              skipSeparationSpace(state, true, -1);

              if (
                state.lineIndent === 0 &&
                state.input.charCodeAt(state.position) === 0x2d /* - */ &&
                state.input.charCodeAt(state.position + 1) === 0x2d /* - */ &&
                state.input.charCodeAt(state.position + 2) === 0x2d /* - */
              ) {
                state.position += 3;
                skipSeparationSpace(state, true, -1);
              } else if (hasDirectives) {
                throwError(state, 'directives end mark is expected');
              }

              composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
              skipSeparationSpace(state, true, -1);

              if (
                state.checkLineBreaks &&
                PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))
              ) {
                throwWarning(state, 'non-ASCII line breaks are interpreted as content');
              }

              state.documents.push(state.result);

              if (state.position === state.lineStart && testDocumentSeparator(state)) {
                if (state.input.charCodeAt(state.position) === 0x2e /* . */) {
                  state.position += 3;
                  skipSeparationSpace(state, true, -1);
                }
                return;
              }

              if (state.position < state.length - 1) {
                throwError(state, 'end of the stream or a document separator is expected');
              } else {
                return;
              }
            }

            function loadDocuments(input, options) {
              input = String(input);
              options = options || {};

              if (input.length !== 0) {
                if (
                  input.charCodeAt(input.length - 1) !== 0x0a /* LF */ &&
                  input.charCodeAt(input.length - 1) !== 0x0d /* CR */
                ) {
                  input += '\n';
                }
                if (input.charCodeAt(0) === 0xfeff) {
                  input = input.slice(1);
                }
              }

              var state = new State(input, options);
              state.input += '\0';

              while (state.input.charCodeAt(state.position) === 0x20 /* Space */) {
                state.lineIndent += 1;
                state.position += 1;
              }

              while (state.position < state.length - 1) {
                readDocument(state);
              }

              return state.documents;
            }

            function loadAll(input, iterator, options) {
              var documents = loadDocuments(input, options),
                index,
                length;

              if (typeof iterator !== 'function') {
                return documents;
              }

              for (index = 0, length = documents.length; index < length; index += 1) {
                iterator(documents[index]);
              }
            }

            function load(input, options) {
              var documents = loadDocuments(input, options);

              if (documents.length === 0) {
                return undefined;
              } else if (documents.length === 1) {
                return documents[0];
              }
              throw new YAMLException('expected a single document in the stream, but found more');
            }

            function safeLoadAll(input, output, options) {
              if (typeof output === 'function') {
                loadAll(input, output, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
              } else {
                return loadAll(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
              }
            }

            function safeLoad(input, options) {
              return load(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
            }

            module.exports.loadAll = loadAll;
            module.exports.load = load;
            module.exports.safeLoadAll = safeLoadAll;
            module.exports.safeLoad = safeLoad;
          },
          { './common': 5, './exception': 7, './mark': 9, './schema/default_full': 12, './schema/default_safe': 13 },
        ],
        9: [
          function (require, module, exports) {
            'use strict';

            var common = require('./common');

            function Mark(name, buffer, position, line, column) {
              this.name = name;
              this.buffer = buffer;
              this.position = position;
              this.line = line;
              this.column = column;
            }

            Mark.prototype.getSnippet = function getSnippet(indent, maxLength) {
              var head, start, tail, end, snippet;

              if (!this.buffer) return null;

              indent = indent || 4;
              maxLength = maxLength || 75;

              head = '';
              start = this.position;

              while (start > 0 && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(start - 1)) === -1) {
                start -= 1;
                if (this.position - start > maxLength / 2 - 1) {
                  head = ' ... ';
                  start += 5;
                  break;
                }
              }

              tail = '';
              end = this.position;

              while (end < this.buffer.length && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(end)) === -1) {
                end += 1;
                if (end - this.position > maxLength / 2 - 1) {
                  tail = ' ... ';
                  end -= 5;
                  break;
                }
              }

              snippet = this.buffer.slice(start, end);

              return (
                common.repeat(' ', indent) +
                head +
                snippet +
                tail +
                '\n' +
                common.repeat(' ', indent + this.position - start + head.length) +
                '^'
              );
            };

            Mark.prototype.toString = function toString(compact) {
              var snippet,
                where = '';

              if (this.name) {
                where += 'in "' + this.name + '" ';
              }

              where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1);

              if (!compact) {
                snippet = this.getSnippet();

                if (snippet) {
                  where += ':\n' + snippet;
                }
              }

              return where;
            };

            module.exports = Mark;
          },
          { './common': 5 },
        ],
        10: [
          function (require, module, exports) {
            'use strict';

            var common = require('./common');
            var YAMLException = require('./exception');
            var Type = require('./type');

            function compileList(schema, name, result) {
              var exclude = [];

              schema.include.forEach(function (includedSchema) {
                result = compileList(includedSchema, name, result);
              });

              schema[name].forEach(function (currentType) {
                result.forEach(function (previousType, previousIndex) {
                  if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {
                    exclude.push(previousIndex);
                  }
                });

                result.push(currentType);
              });

              return result.filter(function (type, index) {
                return exclude.indexOf(index) === -1;
              });
            }

            function compileMap(/* lists... */) {
              var result = {
                  scalar: {},
                  sequence: {},
                  mapping: {},
                  fallback: {},
                },
                index,
                length;

              function collectType(type) {
                result[type.kind][type.tag] = result['fallback'][type.tag] = type;
              }

              for (index = 0, length = arguments.length; index < length; index += 1) {
                arguments[index].forEach(collectType);
              }
              return result;
            }

            function Schema(definition) {
              this.include = definition.include || [];
              this.implicit = definition.implicit || [];
              this.explicit = definition.explicit || [];

              this.implicit.forEach(function (type) {
                if (type.loadKind && type.loadKind !== 'scalar') {
                  throw new YAMLException(
                    'There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.',
                  );
                }
              });

              this.compiledImplicit = compileList(this, 'implicit', []);
              this.compiledExplicit = compileList(this, 'explicit', []);
              this.compiledTypeMap = compileMap(this.compiledImplicit, this.compiledExplicit);
            }

            Schema.DEFAULT = null;

            Schema.create = function createSchema() {
              var schemas, types;

              switch (arguments.length) {
                case 1:
                  schemas = Schema.DEFAULT;
                  types = arguments[0];
                  break;

                case 2:
                  schemas = arguments[0];
                  types = arguments[1];
                  break;

                default:
                  throw new YAMLException('Wrong number of arguments for Schema.create function');
              }

              schemas = common.toArray(schemas);
              types = common.toArray(types);

              if (
                !schemas.every(function (schema) {
                  return schema instanceof Schema;
                })
              ) {
                throw new YAMLException(
                  'Specified list of super schemas (or a single Schema object) contains a non-Schema object.',
                );
              }

              if (
                !types.every(function (type) {
                  return type instanceof Type;
                })
              ) {
                throw new YAMLException(
                  'Specified list of YAML types (or a single Type object) contains a non-Type object.',
                );
              }

              return new Schema({
                include: schemas,
                explicit: types,
              });
            };

            module.exports = Schema;
          },
          { './common': 5, './exception': 7, './type': 16 },
        ],
        11: [
          function (require, module, exports) {
            'use strict';

            var Schema = require('../schema');

            module.exports = new Schema({
              include: [require('./json')],
            });
          },
          { '../schema': 10, './json': 15 },
        ],
        12: [
          function (require, module, exports) {
            'use strict';

            var Schema = require('../schema');

            module.exports = Schema.DEFAULT = new Schema({
              include: [require('./default_safe')],
              explicit: [require('../type/js/undefined'), require('../type/js/regexp'), require('../type/js/function')],
            });
          },
          {
            '../schema': 10,
            '../type/js/function': 21,
            '../type/js/regexp': 22,
            '../type/js/undefined': 23,
            './default_safe': 13,
          },
        ],
        13: [
          function (require, module, exports) {
            'use strict';

            var Schema = require('../schema');

            module.exports = new Schema({
              include: [require('./core')],
              implicit: [require('../type/timestamp'), require('../type/merge')],
              explicit: [
                require('../type/binary'),
                require('../type/omap'),
                require('../type/pairs'),
                require('../type/set'),
              ],
            });
          },
          {
            '../schema': 10,
            '../type/binary': 17,
            '../type/merge': 25,
            '../type/omap': 27,
            '../type/pairs': 28,
            '../type/set': 30,
            '../type/timestamp': 32,
            './core': 11,
          },
        ],
        14: [
          function (require, module, exports) {
            'use strict';

            var Schema = require('../schema');

            module.exports = new Schema({
              explicit: [require('../type/str'), require('../type/seq'), require('../type/map')],
            });
          },
          { '../schema': 10, '../type/map': 24, '../type/seq': 29, '../type/str': 31 },
        ],
        15: [
          function (require, module, exports) {
            'use strict';

            var Schema = require('../schema');

            module.exports = new Schema({
              include: [require('./failsafe')],
              implicit: [
                require('../type/null'),
                require('../type/bool'),
                require('../type/int'),
                require('../type/float'),
              ],
            });
          },
          {
            '../schema': 10,
            '../type/bool': 18,
            '../type/float': 19,
            '../type/int': 20,
            '../type/null': 26,
            './failsafe': 14,
          },
        ],
        16: [
          function (require, module, exports) {
            'use strict';

            var YAMLException = require('./exception');

            var TYPE_CONSTRUCTOR_OPTIONS = [
              'kind',
              'resolve',
              'construct',
              'instanceOf',
              'predicate',
              'represent',
              'defaultStyle',
              'styleAliases',
            ];

            var YAML_NODE_KINDS = ['scalar', 'sequence', 'mapping'];

            function compileStyleAliases(map) {
              var result = {};

              if (map !== null) {
                Object.keys(map).forEach(function (style) {
                  map[style].forEach(function (alias) {
                    result[String(alias)] = style;
                  });
                });
              }

              return result;
            }

            function Type(tag, options) {
              options = options || {};

              Object.keys(options).forEach(function (name) {
                if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
                  throw new YAMLException(
                    'Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.',
                  );
                }
              });
              this.tag = tag;
              this.kind = options['kind'] || null;
              this.resolve =
                options['resolve'] ||
                function () {
                  return true;
                };
              this.construct =
                options['construct'] ||
                function (data) {
                  return data;
                };
              this.instanceOf = options['instanceOf'] || null;
              this.predicate = options['predicate'] || null;
              this.represent = options['represent'] || null;
              this.defaultStyle = options['defaultStyle'] || null;
              this.styleAliases = compileStyleAliases(options['styleAliases'] || null);

              if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
                throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
              }
            }

            module.exports = Type;
          },
          { './exception': 7 },
        ],
        17: [
          function (require, module, exports) {
            'use strict';

            var NodeBuffer;

            try {
              var _require = require;
              NodeBuffer = _require('buffer').Buffer;
            } catch (__) {}

            var Type = require('../type');
            var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';

            function resolveYamlBinary(data) {
              if (data === null) return false;

              var code,
                idx,
                bitlen = 0,
                max = data.length,
                map = BASE64_MAP;
              for (idx = 0; idx < max; idx++) {
                code = map.indexOf(data.charAt(idx));
                if (code > 64) continue;
                if (code < 0) return false;

                bitlen += 6;
              }
              return bitlen % 8 === 0;
            }

            function constructYamlBinary(data) {
              var idx,
                tailbits,
                input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan
                max = input.length,
                map = BASE64_MAP,
                bits = 0,
                result = [];

              for (idx = 0; idx < max; idx++) {
                if (idx % 4 === 0 && idx) {
                  result.push((bits >> 16) & 0xff);
                  result.push((bits >> 8) & 0xff);
                  result.push(bits & 0xff);
                }

                bits = (bits << 6) | map.indexOf(input.charAt(idx));
              }

              tailbits = (max % 4) * 6;

              if (tailbits === 0) {
                result.push((bits >> 16) & 0xff);
                result.push((bits >> 8) & 0xff);
                result.push(bits & 0xff);
              } else if (tailbits === 18) {
                result.push((bits >> 10) & 0xff);
                result.push((bits >> 2) & 0xff);
              } else if (tailbits === 12) {
                result.push((bits >> 4) & 0xff);
              }
              if (NodeBuffer) {
                return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result);
              }

              return result;
            }

            function representYamlBinary(object /*, style*/) {
              var result = '',
                bits = 0,
                idx,
                tail,
                max = object.length,
                map = BASE64_MAP;

              for (idx = 0; idx < max; idx++) {
                if (idx % 3 === 0 && idx) {
                  result += map[(bits >> 18) & 0x3f];
                  result += map[(bits >> 12) & 0x3f];
                  result += map[(bits >> 6) & 0x3f];
                  result += map[bits & 0x3f];
                }

                bits = (bits << 8) + object[idx];
              }

              tail = max % 3;

              if (tail === 0) {
                result += map[(bits >> 18) & 0x3f];
                result += map[(bits >> 12) & 0x3f];
                result += map[(bits >> 6) & 0x3f];
                result += map[bits & 0x3f];
              } else if (tail === 2) {
                result += map[(bits >> 10) & 0x3f];
                result += map[(bits >> 4) & 0x3f];
                result += map[(bits << 2) & 0x3f];
                result += map[64];
              } else if (tail === 1) {
                result += map[(bits >> 2) & 0x3f];
                result += map[(bits << 4) & 0x3f];
                result += map[64];
                result += map[64];
              }

              return result;
            }

            function isBinary(object) {
              return NodeBuffer && NodeBuffer.isBuffer(object);
            }

            module.exports = new Type('tag:yaml.org,2002:binary', {
              kind: 'scalar',
              resolve: resolveYamlBinary,
              construct: constructYamlBinary,
              predicate: isBinary,
              represent: representYamlBinary,
            });
          },
          { '../type': 16 },
        ],
        18: [
          function (require, module, exports) {
            'use strict';

            var Type = require('../type');

            function resolveYamlBoolean(data) {
              if (data === null) return false;

              var max = data.length;

              return (
                (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||
                (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'))
              );
            }

            function constructYamlBoolean(data) {
              return data === 'true' || data === 'True' || data === 'TRUE';
            }

            function isBoolean(object) {
              return Object.prototype.toString.call(object) === '[object Boolean]';
            }

            module.exports = new Type('tag:yaml.org,2002:bool', {
              kind: 'scalar',
              resolve: resolveYamlBoolean,
              construct: constructYamlBoolean,
              predicate: isBoolean,
              represent: {
                lowercase: function (object) {
                  return object ? 'true' : 'false';
                },
                uppercase: function (object) {
                  return object ? 'TRUE' : 'FALSE';
                },
                camelcase: function (object) {
                  return object ? 'True' : 'False';
                },
              },
              defaultStyle: 'lowercase',
            });
          },
          { '../type': 16 },
        ],
        19: [
          function (require, module, exports) {
            'use strict';

            var common = require('../common');
            var Type = require('../type');

            var YAML_FLOAT_PATTERN = new RegExp(
              '^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +
                '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' +
                '|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*' +
                '|[-+]?\\.(?:inf|Inf|INF)' +
                '|\\.(?:nan|NaN|NAN))$',
            );

            function resolveYamlFloat(data) {
              if (data === null) return false;

              if (!YAML_FLOAT_PATTERN.test(data) || data[data.length - 1] === '_') {
                return false;
              }

              return true;
            }

            function constructYamlFloat(data) {
              var value, sign, base, digits;

              value = data.replace(/_/g, '').toLowerCase();
              sign = value[0] === '-' ? -1 : 1;
              digits = [];

              if ('+-'.indexOf(value[0]) >= 0) {
                value = value.slice(1);
              }

              if (value === '.inf') {
                return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
              } else if (value === '.nan') {
                return NaN;
              } else if (value.indexOf(':') >= 0) {
                value.split(':').forEach(function (v) {
                  digits.unshift(parseFloat(v, 10));
                });

                value = 0.0;
                base = 1;

                digits.forEach(function (d) {
                  value += d * base;
                  base *= 60;
                });

                return sign * value;
              }
              return sign * parseFloat(value, 10);
            }

            var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;

            function representYamlFloat(object, style) {
              var res;

              if (isNaN(object)) {
                switch (style) {
                  case 'lowercase':
                    return '.nan';
                  case 'uppercase':
                    return '.NAN';
                  case 'camelcase':
                    return '.NaN';
                }
              } else if (Number.POSITIVE_INFINITY === object) {
                switch (style) {
                  case 'lowercase':
                    return '.inf';
                  case 'uppercase':
                    return '.INF';
                  case 'camelcase':
                    return '.Inf';
                }
              } else if (Number.NEGATIVE_INFINITY === object) {
                switch (style) {
                  case 'lowercase':
                    return '-.inf';
                  case 'uppercase':
                    return '-.INF';
                  case 'camelcase':
                    return '-.Inf';
                }
              } else if (common.isNegativeZero(object)) {
                return '-0.0';
              }

              res = object.toString(10);

              return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res;
            }

            function isFloat(object) {
              return (
                Object.prototype.toString.call(object) === '[object Number]' &&
                (object % 1 !== 0 || common.isNegativeZero(object))
              );
            }

            module.exports = new Type('tag:yaml.org,2002:float', {
              kind: 'scalar',
              resolve: resolveYamlFloat,
              construct: constructYamlFloat,
              predicate: isFloat,
              represent: representYamlFloat,
              defaultStyle: 'lowercase',
            });
          },
          { '../common': 5, '../type': 16 },
        ],
        20: [
          function (require, module, exports) {
            'use strict';

            var common = require('../common');
            var Type = require('../type');

            function isHexCode(c) {
              return (
                (c /* 0 */ >= 0x30 && c <= 0x39) /* 9 */ ||
                (c /* A */ >= 0x41 && c <= 0x46) /* F */ ||
                (c /* a */ >= 0x61 && c <= 0x66) /* f */
              );
            }

            function isOctCode(c) {
              return c /* 0 */ >= 0x30 && c <= 0x37 /* 7 */;
            }

            function isDecCode(c) {
              return c /* 0 */ >= 0x30 && c <= 0x39 /* 9 */;
            }

            function resolveYamlInteger(data) {
              if (data === null) return false;

              var max = data.length,
                index = 0,
                hasDigits = false,
                ch;

              if (!max) return false;

              ch = data[index];
              if (ch === '-' || ch === '+') {
                ch = data[++index];
              }

              if (ch === '0') {
                if (index + 1 === max) return true;
                ch = data[++index];

                if (ch === 'b') {
                  index++;

                  for (; index < max; index++) {
                    ch = data[index];
                    if (ch === '_') continue;
                    if (ch !== '0' && ch !== '1') return false;
                    hasDigits = true;
                  }
                  return hasDigits && ch !== '_';
                }

                if (ch === 'x') {
                  index++;

                  for (; index < max; index++) {
                    ch = data[index];
                    if (ch === '_') continue;
                    if (!isHexCode(data.charCodeAt(index))) return false;
                    hasDigits = true;
                  }
                  return hasDigits && ch !== '_';
                }
                for (; index < max; index++) {
                  ch = data[index];
                  if (ch === '_') continue;
                  if (!isOctCode(data.charCodeAt(index))) return false;
                  hasDigits = true;
                }
                return hasDigits && ch !== '_';
              }
              if (ch === '_') return false;

              for (; index < max; index++) {
                ch = data[index];
                if (ch === '_') continue;
                if (ch === ':') break;
                if (!isDecCode(data.charCodeAt(index))) {
                  return false;
                }
                hasDigits = true;
              }
              if (!hasDigits || ch === '_') return false;
              if (ch !== ':') return true;
              return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
            }

            function constructYamlInteger(data) {
              var value = data,
                sign = 1,
                ch,
                base,
                digits = [];

              if (value.indexOf('_') !== -1) {
                value = value.replace(/_/g, '');
              }

              ch = value[0];

              if (ch === '-' || ch === '+') {
                if (ch === '-') sign = -1;
                value = value.slice(1);
                ch = value[0];
              }

              if (value === '0') return 0;

              if (ch === '0') {
                if (value[1] === 'b') return sign * parseInt(value.slice(2), 2);
                if (value[1] === 'x') return sign * parseInt(value, 16);
                return sign * parseInt(value, 8);
              }

              if (value.indexOf(':') !== -1) {
                value.split(':').forEach(function (v) {
                  digits.unshift(parseInt(v, 10));
                });

                value = 0;
                base = 1;

                digits.forEach(function (d) {
                  value += d * base;
                  base *= 60;
                });

                return sign * value;
              }

              return sign * parseInt(value, 10);
            }

            function isInteger(object) {
              return (
                Object.prototype.toString.call(object) === '[object Number]' &&
                object % 1 === 0 &&
                !common.isNegativeZero(object)
              );
            }

            module.exports = new Type('tag:yaml.org,2002:int', {
              kind: 'scalar',
              resolve: resolveYamlInteger,
              construct: constructYamlInteger,
              predicate: isInteger,
              represent: {
                binary: function (obj) {
                  return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1);
                },
                octal: function (obj) {
                  return obj >= 0 ? '0' + obj.toString(8) : '-0' + obj.toString(8).slice(1);
                },
                decimal: function (obj) {
                  return obj.toString(10);
                },
                hexadecimal: function (obj) {
                  return obj >= 0
                    ? '0x' + obj.toString(16).toUpperCase()
                    : '-0x' + obj.toString(16).toUpperCase().slice(1);
                },
              },
              defaultStyle: 'decimal',
              styleAliases: {
                binary: [2, 'bin'],
                octal: [8, 'oct'],
                decimal: [10, 'dec'],
                hexadecimal: [16, 'hex'],
              },
            });
          },
          { '../common': 5, '../type': 16 },
        ],
        21: [
          function (require, module, exports) {
            'use strict';

            var esprima;
            try {
              var _require = require;
              esprima = _require('esprima');
            } catch (_) {
              if (typeof window !== 'undefined') esprima = window.esprima;
            }

            var Type = require('../../type');

            function resolveJavascriptFunction(data) {
              if (data === null) return false;

              try {
                var source = '(' + data + ')',
                  ast = esprima.parse(source, { range: true });

                if (
                  ast.type !== 'Program' ||
                  ast.body.length !== 1 ||
                  ast.body[0].type !== 'ExpressionStatement' ||
                  (ast.body[0].expression.type !== 'ArrowFunctionExpression' &&
                    ast.body[0].expression.type !== 'FunctionExpression')
                ) {
                  return false;
                }

                return true;
              } catch (err) {
                return false;
              }
            }

            function constructJavascriptFunction(data) {
              var source = '(' + data + ')',
                ast = esprima.parse(source, { range: true }),
                params = [],
                body;

              if (
                ast.type !== 'Program' ||
                ast.body.length !== 1 ||
                ast.body[0].type !== 'ExpressionStatement' ||
                (ast.body[0].expression.type !== 'ArrowFunctionExpression' &&
                  ast.body[0].expression.type !== 'FunctionExpression')
              ) {
                throw new Error('Failed to resolve function');
              }

              ast.body[0].expression.params.forEach(function (param) {
                params.push(param.name);
              });

              body = ast.body[0].expression.body.range;
              if (ast.body[0].expression.body.type === 'BlockStatement') {
                return new Function(params, source.slice(body[0] + 1, body[1] - 1));
              }
              return new Function(params, 'return ' + source.slice(body[0], body[1]));
            }

            function representJavascriptFunction(object /*, style*/) {
              return object.toString();
            }

            function isFunction(object) {
              return Object.prototype.toString.call(object) === '[object Function]';
            }

            module.exports = new Type('tag:yaml.org,2002:js/function', {
              kind: 'scalar',
              resolve: resolveJavascriptFunction,
              construct: constructJavascriptFunction,
              predicate: isFunction,
              represent: representJavascriptFunction,
            });
          },
          { '../../type': 16 },
        ],
        22: [
          function (require, module, exports) {
            'use strict';

            var Type = require('../../type');

            function resolveJavascriptRegExp(data) {
              if (data === null) return false;
              if (data.length === 0) return false;

              var regexp = data,
                tail = /\/([gim]*)$/.exec(data),
                modifiers = '';
              if (regexp[0] === '/') {
                if (tail) modifiers = tail[1];

                if (modifiers.length > 3) return false;
                if (regexp[regexp.length - modifiers.length - 1] !== '/') return false;
              }

              return true;
            }

            function constructJavascriptRegExp(data) {
              var regexp = data,
                tail = /\/([gim]*)$/.exec(data),
                modifiers = '';
              if (regexp[0] === '/') {
                if (tail) modifiers = tail[1];
                regexp = regexp.slice(1, regexp.length - modifiers.length - 1);
              }

              return new RegExp(regexp, modifiers);
            }

            function representJavascriptRegExp(object /*, style*/) {
              var result = '/' + object.source + '/';

              if (object.global) result += 'g';
              if (object.multiline) result += 'm';
              if (object.ignoreCase) result += 'i';

              return result;
            }

            function isRegExp(object) {
              return Object.prototype.toString.call(object) === '[object RegExp]';
            }

            module.exports = new Type('tag:yaml.org,2002:js/regexp', {
              kind: 'scalar',
              resolve: resolveJavascriptRegExp,
              construct: constructJavascriptRegExp,
              predicate: isRegExp,
              represent: representJavascriptRegExp,
            });
          },
          { '../../type': 16 },
        ],
        23: [
          function (require, module, exports) {
            'use strict';

            var Type = require('../../type');

            function resolveJavascriptUndefined() {
              return true;
            }

            function constructJavascriptUndefined() {
              return undefined;
            }

            function representJavascriptUndefined() {
              return '';
            }

            function isUndefined(object) {
              return typeof object === 'undefined';
            }

            module.exports = new Type('tag:yaml.org,2002:js/undefined', {
              kind: 'scalar',
              resolve: resolveJavascriptUndefined,
              construct: constructJavascriptUndefined,
              predicate: isUndefined,
              represent: representJavascriptUndefined,
            });
          },
          { '../../type': 16 },
        ],
        24: [
          function (require, module, exports) {
            'use strict';

            var Type = require('../type');

            module.exports = new Type('tag:yaml.org,2002:map', {
              kind: 'mapping',
              construct: function (data) {
                return data !== null ? data : {};
              },
            });
          },
          { '../type': 16 },
        ],
        25: [
          function (require, module, exports) {
            'use strict';

            var Type = require('../type');

            function resolveYamlMerge(data) {
              return data === '<<' || data === null;
            }

            module.exports = new Type('tag:yaml.org,2002:merge', {
              kind: 'scalar',
              resolve: resolveYamlMerge,
            });
          },
          { '../type': 16 },
        ],
        26: [
          function (require, module, exports) {
            'use strict';

            var Type = require('../type');

            function resolveYamlNull(data) {
              if (data === null) return true;

              var max = data.length;

              return (
                (max === 1 && data === '~') || (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'))
              );
            }

            function constructYamlNull() {
              return null;
            }

            function isNull(object) {
              return object === null;
            }

            module.exports = new Type('tag:yaml.org,2002:null', {
              kind: 'scalar',
              resolve: resolveYamlNull,
              construct: constructYamlNull,
              predicate: isNull,
              represent: {
                canonical: function () {
                  return '~';
                },
                lowercase: function () {
                  return 'null';
                },
                uppercase: function () {
                  return 'NULL';
                },
                camelcase: function () {
                  return 'Null';
                },
              },
              defaultStyle: 'lowercase',
            });
          },
          { '../type': 16 },
        ],
        27: [
          function (require, module, exports) {
            'use strict';

            var Type = require('../type');

            var _hasOwnProperty = Object.prototype.hasOwnProperty;
            var _toString = Object.prototype.toString;

            function resolveYamlOmap(data) {
              if (data === null) return true;

              var objectKeys = [],
                index,
                length,
                pair,
                pairKey,
                pairHasKey,
                object = data;

              for (index = 0, length = object.length; index < length; index += 1) {
                pair = object[index];
                pairHasKey = false;

                if (_toString.call(pair) !== '[object Object]') return false;

                for (pairKey in pair) {
                  if (_hasOwnProperty.call(pair, pairKey)) {
                    if (!pairHasKey) pairHasKey = true;
                    else return false;
                  }
                }

                if (!pairHasKey) return false;

                if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
                else return false;
              }

              return true;
            }

            function constructYamlOmap(data) {
              return data !== null ? data : [];
            }

            module.exports = new Type('tag:yaml.org,2002:omap', {
              kind: 'sequence',
              resolve: resolveYamlOmap,
              construct: constructYamlOmap,
            });
          },
          { '../type': 16 },
        ],
        28: [
          function (require, module, exports) {
            'use strict';

            var Type = require('../type');

            var _toString = Object.prototype.toString;

            function resolveYamlPairs(data) {
              if (data === null) return true;

              var index,
                length,
                pair,
                keys,
                result,
                object = data;

              result = new Array(object.length);

              for (index = 0, length = object.length; index < length; index += 1) {
                pair = object[index];

                if (_toString.call(pair) !== '[object Object]') return false;

                keys = Object.keys(pair);

                if (keys.length !== 1) return false;

                result[index] = [keys[0], pair[keys[0]]];
              }

              return true;
            }

            function constructYamlPairs(data) {
              if (data === null) return [];

              var index,
                length,
                pair,
                keys,
                result,
                object = data;

              result = new Array(object.length);

              for (index = 0, length = object.length; index < length; index += 1) {
                pair = object[index];

                keys = Object.keys(pair);

                result[index] = [keys[0], pair[keys[0]]];
              }

              return result;
            }

            module.exports = new Type('tag:yaml.org,2002:pairs', {
              kind: 'sequence',
              resolve: resolveYamlPairs,
              construct: constructYamlPairs,
            });
          },
          { '../type': 16 },
        ],
        29: [
          function (require, module, exports) {
            'use strict';

            var Type = require('../type');

            module.exports = new Type('tag:yaml.org,2002:seq', {
              kind: 'sequence',
              construct: function (data) {
                return data !== null ? data : [];
              },
            });
          },
          { '../type': 16 },
        ],
        30: [
          function (require, module, exports) {
            'use strict';

            var Type = require('../type');

            var _hasOwnProperty = Object.prototype.hasOwnProperty;

            function resolveYamlSet(data) {
              if (data === null) return true;

              var key,
                object = data;

              for (key in object) {
                if (_hasOwnProperty.call(object, key)) {
                  if (object[key] !== null) return false;
                }
              }

              return true;
            }

            function constructYamlSet(data) {
              return data !== null ? data : {};
            }

            module.exports = new Type('tag:yaml.org,2002:set', {
              kind: 'mapping',
              resolve: resolveYamlSet,
              construct: constructYamlSet,
            });
          },
          { '../type': 16 },
        ],
        31: [
          function (require, module, exports) {
            'use strict';

            var Type = require('../type');

            module.exports = new Type('tag:yaml.org,2002:str', {
              kind: 'scalar',
              construct: function (data) {
                return data !== null ? data : '';
              },
            });
          },
          { '../type': 16 },
        ],
        32: [
          function (require, module, exports) {
            'use strict';

            var Type = require('../type');

            var YAML_DATE_REGEXP = new RegExp(
              '^([0-9][0-9][0-9][0-9])' + // [1] year
                '-([0-9][0-9])' + // [2] month
                '-([0-9][0-9])$',
            ); // [3] day

            var YAML_TIMESTAMP_REGEXP = new RegExp(
              '^([0-9][0-9][0-9][0-9])' + // [1] year
                '-([0-9][0-9]?)' + // [2] month
                '-([0-9][0-9]?)' + // [3] day
                '(?:[Tt]|[ \\t]+)' + // ...
                '([0-9][0-9]?)' + // [4] hour
                ':([0-9][0-9])' + // [5] minute
                ':([0-9][0-9])' + // [6] second
                '(?:\\.([0-9]*))?' + // [7] fraction
                '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour
                '(?::([0-9][0-9]))?))?$',
            ); // [11] tz_minute

            function resolveYamlTimestamp(data) {
              if (data === null) return false;
              if (YAML_DATE_REGEXP.exec(data) !== null) return true;
              if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
              return false;
            }

            function constructYamlTimestamp(data) {
              var match,
                year,
                month,
                day,
                hour,
                minute,
                second,
                fraction = 0,
                delta = null,
                tz_hour,
                tz_minute,
                date;

              match = YAML_DATE_REGEXP.exec(data);
              if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);

              if (match === null) throw new Error('Date resolve error');

              year = +match[1];
              month = +match[2] - 1; // JS month starts with 0
              day = +match[3];

              if (!match[4]) {
                // no hour
                return new Date(Date.UTC(year, month, day));
              }

              hour = +match[4];
              minute = +match[5];
              second = +match[6];

              if (match[7]) {
                fraction = match[7].slice(0, 3);
                while (fraction.length < 3) {
                  // milli-seconds
                  fraction += '0';
                }
                fraction = +fraction;
              }

              if (match[9]) {
                tz_hour = +match[10];
                tz_minute = +(match[11] || 0);
                delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds
                if (match[9] === '-') delta = -delta;
              }

              date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));

              if (delta) date.setTime(date.getTime() - delta);

              return date;
            }

            function representYamlTimestamp(object /*, style*/) {
              return object.toISOString();
            }

            module.exports = new Type('tag:yaml.org,2002:timestamp', {
              kind: 'scalar',
              resolve: resolveYamlTimestamp,
              construct: constructYamlTimestamp,
              instanceOf: Date,
              represent: representYamlTimestamp,
            });
          },
          { '../type': 16 },
        ],
        33: [
          function (require, module, exports) {
            (function (global) {
              var LARGE_ARRAY_SIZE = 200;
              var HASH_UNDEFINED = '__lodash_hash_undefined__';
              var HOT_COUNT = 800,
                HOT_SPAN = 16;
              var MAX_SAFE_INTEGER = 9007199254740991;
              var argsTag = '[object Arguments]',
                arrayTag = '[object Array]',
                asyncTag = '[object AsyncFunction]',
                boolTag = '[object Boolean]',
                dateTag = '[object Date]',
                errorTag = '[object Error]',
                funcTag = '[object Function]',
                genTag = '[object GeneratorFunction]',
                mapTag = '[object Map]',
                numberTag = '[object Number]',
                nullTag = '[object Null]',
                objectTag = '[object Object]',
                proxyTag = '[object Proxy]',
                regexpTag = '[object RegExp]',
                setTag = '[object Set]',
                stringTag = '[object String]',
                undefinedTag = '[object Undefined]',
                weakMapTag = '[object WeakMap]';

              var arrayBufferTag = '[object ArrayBuffer]',
                dataViewTag = '[object DataView]',
                float32Tag = '[object Float32Array]',
                float64Tag = '[object Float64Array]',
                int8Tag = '[object Int8Array]',
                int16Tag = '[object Int16Array]',
                int32Tag = '[object Int32Array]',
                uint8Tag = '[object Uint8Array]',
                uint8ClampedTag = '[object Uint8ClampedArray]',
                uint16Tag = '[object Uint16Array]',
                uint32Tag = '[object Uint32Array]';
              var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
              var reIsHostCtor = /^\[object .+?Constructor\]$/;
              var reIsUint = /^(?:0|[1-9]\d*)$/;
              var typedArrayTags = {};
              typedArrayTags[float32Tag] =
                typedArrayTags[float64Tag] =
                typedArrayTags[int8Tag] =
                typedArrayTags[int16Tag] =
                typedArrayTags[int32Tag] =
                typedArrayTags[uint8Tag] =
                typedArrayTags[uint8ClampedTag] =
                typedArrayTags[uint16Tag] =
                typedArrayTags[uint32Tag] =
                  true;
              typedArrayTags[argsTag] =
                typedArrayTags[arrayTag] =
                typedArrayTags[arrayBufferTag] =
                typedArrayTags[boolTag] =
                typedArrayTags[dataViewTag] =
                typedArrayTags[dateTag] =
                typedArrayTags[errorTag] =
                typedArrayTags[funcTag] =
                typedArrayTags[mapTag] =
                typedArrayTags[numberTag] =
                typedArrayTags[objectTag] =
                typedArrayTags[regexpTag] =
                typedArrayTags[setTag] =
                typedArrayTags[stringTag] =
                typedArrayTags[weakMapTag] =
                  false;
              var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
              var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
              var root = freeGlobal || freeSelf || Function('return this')();
              var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
              var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
              var moduleExports = freeModule && freeModule.exports === freeExports;
              var freeProcess = moduleExports && freeGlobal.process;
              var nodeUtil = (function () {
                try {
                  return freeProcess && freeProcess.binding && freeProcess.binding('util');
                } catch (e) {}
              })();
              var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
              function apply(func, thisArg, args) {
                switch (args.length) {
                  case 0:
                    return func.call(thisArg);
                  case 1:
                    return func.call(thisArg, args[0]);
                  case 2:
                    return func.call(thisArg, args[0], args[1]);
                  case 3:
                    return func.call(thisArg, args[0], args[1], args[2]);
                }
                return func.apply(thisArg, args);
              }
              function baseTimes(n, iteratee) {
                var index = -1,
                  result = Array(n);

                while (++index < n) {
                  result[index] = iteratee(index);
                }
                return result;
              }
              function baseUnary(func) {
                return function (value) {
                  return func(value);
                };
              }
              function getValue(object, key) {
                return object == null ? undefined : object[key];
              }
              function overArg(func, transform) {
                return function (arg) {
                  return func(transform(arg));
                };
              }
              function safeGet(object, key) {
                return key == '__proto__' ? undefined : object[key];
              }
              var arrayProto = Array.prototype,
                funcProto = Function.prototype,
                objectProto = Object.prototype;
              var coreJsData = root['__core-js_shared__'];
              var funcToString = funcProto.toString;
              var hasOwnProperty = objectProto.hasOwnProperty;
              var maskSrcKey = (function () {
                var uid = /[^.]+$/.exec((coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO) || '');
                return uid ? 'Symbol(src)_1.' + uid : '';
              })();
              var nativeObjectToString = objectProto.toString;
              var objectCtorString = funcToString.call(Object);
              var reIsNative = RegExp(
                '^' +
                  funcToString
                    .call(hasOwnProperty)
                    .replace(reRegExpChar, '\\$&')
                    .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') +
                  '$',
              );
              var Buffer = moduleExports ? root.Buffer : undefined,
                Symbol = root.Symbol,
                Uint8Array = root.Uint8Array,
                allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,
                getPrototype = overArg(Object.getPrototypeOf, Object),
                objectCreate = Object.create,
                propertyIsEnumerable = objectProto.propertyIsEnumerable,
                splice = arrayProto.splice,
                symToStringTag = Symbol ? Symbol.toStringTag : undefined;

              var defineProperty = (function () {
                try {
                  var func = getNative(Object, 'defineProperty');
                  func({}, '', {});
                  return func;
                } catch (e) {}
              })();
              var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
                nativeMax = Math.max,
                nativeNow = Date.now;
              var Map = getNative(root, 'Map'),
                nativeCreate = getNative(Object, 'create');
              var baseCreate = (function () {
                function object() {}
                return function (proto) {
                  if (!isObject(proto)) {
                    return {};
                  }
                  if (objectCreate) {
                    return objectCreate(proto);
                  }
                  object.prototype = proto;
                  var result = new object();
                  object.prototype = undefined;
                  return result;
                };
              })();
              function Hash(entries) {
                var index = -1,
                  length = entries == null ? 0 : entries.length;

                this.clear();
                while (++index < length) {
                  var entry = entries[index];
                  this.set(entry[0], entry[1]);
                }
              }
              function hashClear() {
                this.__data__ = nativeCreate ? nativeCreate(null) : {};
                this.size = 0;
              }
              function hashDelete(key) {
                var result = this.has(key) && delete this.__data__[key];
                this.size -= result ? 1 : 0;
                return result;
              }
              function hashGet(key) {
                var data = this.__data__;
                if (nativeCreate) {
                  var result = data[key];
                  return result === HASH_UNDEFINED ? undefined : result;
                }
                return hasOwnProperty.call(data, key) ? data[key] : undefined;
              }
              function hashHas(key) {
                var data = this.__data__;
                return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
              }
              function hashSet(key, value) {
                var data = this.__data__;
                this.size += this.has(key) ? 0 : 1;
                data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;
                return this;
              }
              Hash.prototype.clear = hashClear;
              Hash.prototype['delete'] = hashDelete;
              Hash.prototype.get = hashGet;
              Hash.prototype.has = hashHas;
              Hash.prototype.set = hashSet;
              function ListCache(entries) {
                var index = -1,
                  length = entries == null ? 0 : entries.length;

                this.clear();
                while (++index < length) {
                  var entry = entries[index];
                  this.set(entry[0], entry[1]);
                }
              }
              function listCacheClear() {
                this.__data__ = [];
                this.size = 0;
              }
              function listCacheDelete(key) {
                var data = this.__data__,
                  index = assocIndexOf(data, key);

                if (index < 0) {
                  return false;
                }
                var lastIndex = data.length - 1;
                if (index == lastIndex) {
                  data.pop();
                } else {
                  splice.call(data, index, 1);
                }
                --this.size;
                return true;
              }
              function listCacheGet(key) {
                var data = this.__data__,
                  index = assocIndexOf(data, key);

                return index < 0 ? undefined : data[index][1];
              }
              function listCacheHas(key) {
                return assocIndexOf(this.__data__, key) > -1;
              }
              function listCacheSet(key, value) {
                var data = this.__data__,
                  index = assocIndexOf(data, key);

                if (index < 0) {
                  ++this.size;
                  data.push([key, value]);
                } else {
                  data[index][1] = value;
                }
                return this;
              }
              ListCache.prototype.clear = listCacheClear;
              ListCache.prototype['delete'] = listCacheDelete;
              ListCache.prototype.get = listCacheGet;
              ListCache.prototype.has = listCacheHas;
              ListCache.prototype.set = listCacheSet;
              function MapCache(entries) {
                var index = -1,
                  length = entries == null ? 0 : entries.length;

                this.clear();
                while (++index < length) {
                  var entry = entries[index];
                  this.set(entry[0], entry[1]);
                }
              }
              function mapCacheClear() {
                this.size = 0;
                this.__data__ = {
                  hash: new Hash(),
                  map: new (Map || ListCache)(),
                  string: new Hash(),
                };
              }
              function mapCacheDelete(key) {
                var result = getMapData(this, key)['delete'](key);
                this.size -= result ? 1 : 0;
                return result;
              }
              function mapCacheGet(key) {
                return getMapData(this, key).get(key);
              }
              function mapCacheHas(key) {
                return getMapData(this, key).has(key);
              }
              function mapCacheSet(key, value) {
                var data = getMapData(this, key),
                  size = data.size;

                data.set(key, value);
                this.size += data.size == size ? 0 : 1;
                return this;
              }
              MapCache.prototype.clear = mapCacheClear;
              MapCache.prototype['delete'] = mapCacheDelete;
              MapCache.prototype.get = mapCacheGet;
              MapCache.prototype.has = mapCacheHas;
              MapCache.prototype.set = mapCacheSet;
              function Stack(entries) {
                var data = (this.__data__ = new ListCache(entries));
                this.size = data.size;
              }
              function stackClear() {
                this.__data__ = new ListCache();
                this.size = 0;
              }
              function stackDelete(key) {
                var data = this.__data__,
                  result = data['delete'](key);

                this.size = data.size;
                return result;
              }
              function stackGet(key) {
                return this.__data__.get(key);
              }
              function stackHas(key) {
                return this.__data__.has(key);
              }
              function stackSet(key, value) {
                var data = this.__data__;
                if (data instanceof ListCache) {
                  var pairs = data.__data__;
                  if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
                    pairs.push([key, value]);
                    this.size = ++data.size;
                    return this;
                  }
                  data = this.__data__ = new MapCache(pairs);
                }
                data.set(key, value);
                this.size = data.size;
                return this;
              }
              Stack.prototype.clear = stackClear;
              Stack.prototype['delete'] = stackDelete;
              Stack.prototype.get = stackGet;
              Stack.prototype.has = stackHas;
              Stack.prototype.set = stackSet;
              function arrayLikeKeys(value, inherited) {
                var isArr = isArray(value),
                  isArg = !isArr && isArguments(value),
                  isBuff = !isArr && !isArg && isBuffer(value),
                  isType = !isArr && !isArg && !isBuff && isTypedArray(value),
                  skipIndexes = isArr || isArg || isBuff || isType,
                  result = skipIndexes ? baseTimes(value.length, String) : [],
                  length = result.length;

                for (var key in value) {
                  if (
                    (inherited || hasOwnProperty.call(value, key)) &&
                    !(
                      skipIndexes &&
                      (key == 'length' ||
                        (isBuff && (key == 'offset' || key == 'parent')) ||
                        (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
                        isIndex(key, length))
                    )
                  ) {
                    result.push(key);
                  }
                }
                return result;
              }
              function assignMergeValue(object, key, value) {
                if ((value !== undefined && !eq(object[key], value)) || (value === undefined && !(key in object))) {
                  baseAssignValue(object, key, value);
                }
              }
              function assignValue(object, key, value) {
                var objValue = object[key];
                if (
                  !(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
                  (value === undefined && !(key in object))
                ) {
                  baseAssignValue(object, key, value);
                }
              }
              function assocIndexOf(array, key) {
                var length = array.length;
                while (length--) {
                  if (eq(array[length][0], key)) {
                    return length;
                  }
                }
                return -1;
              }
              function baseAssignValue(object, key, value) {
                if (key == '__proto__' && defineProperty) {
                  defineProperty(object, key, {
                    configurable: true,
                    enumerable: true,
                    value: value,
                    writable: true,
                  });
                } else {
                  object[key] = value;
                }
              }
              var baseFor = createBaseFor();
              function baseGetTag(value) {
                if (value == null) {
                  return value === undefined ? undefinedTag : nullTag;
                }
                return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
              }
              function baseIsArguments(value) {
                return isObjectLike(value) && baseGetTag(value) == argsTag;
              }
              function baseIsNative(value) {
                if (!isObject(value) || isMasked(value)) {
                  return false;
                }
                var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
                return pattern.test(toSource(value));
              }
              function baseIsTypedArray(value) {
                return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
              }
              function baseKeysIn(object) {
                if (!isObject(object)) {
                  return nativeKeysIn(object);
                }
                var isProto = isPrototype(object),
                  result = [];

                for (var key in object) {
                  if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
                    result.push(key);
                  }
                }
                return result;
              }
              function baseMerge(object, source, srcIndex, customizer, stack) {
                if (object === source) {
                  return;
                }
                baseFor(
                  source,
                  function (srcValue, key) {
                    if (isObject(srcValue)) {
                      stack || (stack = new Stack());
                      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
                    } else {
                      var newValue = customizer
                        ? customizer(safeGet(object, key), srcValue, key + '', object, source, stack)
                        : undefined;

                      if (newValue === undefined) {
                        newValue = srcValue;
                      }
                      assignMergeValue(object, key, newValue);
                    }
                  },
                  keysIn,
                );
              }
              function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
                var objValue = safeGet(object, key),
                  srcValue = safeGet(source, key),
                  stacked = stack.get(srcValue);

                if (stacked) {
                  assignMergeValue(object, key, stacked);
                  return;
                }
                var newValue = customizer ? customizer(objValue, srcValue, key + '', object, source, stack) : undefined;

                var isCommon = newValue === undefined;

                if (isCommon) {
                  var isArr = isArray(srcValue),
                    isBuff = !isArr && isBuffer(srcValue),
                    isTyped = !isArr && !isBuff && isTypedArray(srcValue);

                  newValue = srcValue;
                  if (isArr || isBuff || isTyped) {
                    if (isArray(objValue)) {
                      newValue = objValue;
                    } else if (isArrayLikeObject(objValue)) {
                      newValue = copyArray(objValue);
                    } else if (isBuff) {
                      isCommon = false;
                      newValue = cloneBuffer(srcValue, true);
                    } else if (isTyped) {
                      isCommon = false;
                      newValue = cloneTypedArray(srcValue, true);
                    } else {
                      newValue = [];
                    }
                  } else if (isPlainObject(srcValue) || isArguments(srcValue)) {
                    newValue = objValue;
                    if (isArguments(objValue)) {
                      newValue = toPlainObject(objValue);
                    } else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
                      newValue = initCloneObject(srcValue);
                    }
                  } else {
                    isCommon = false;
                  }
                }
                if (isCommon) {
                  stack.set(srcValue, newValue);
                  mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
                  stack['delete'](srcValue);
                }
                assignMergeValue(object, key, newValue);
              }
              function baseRest(func, start) {
                return setToString(overRest(func, start, identity), func + '');
              }
              var baseSetToString = !defineProperty
                ? identity
                : function (func, string) {
                    return defineProperty(func, 'toString', {
                      configurable: true,
                      enumerable: false,
                      value: constant(string),
                      writable: true,
                    });
                  };
              function cloneBuffer(buffer, isDeep) {
                if (isDeep) {
                  return buffer.slice();
                }
                var length = buffer.length,
                  result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);

                buffer.copy(result);
                return result;
              }
              function cloneArrayBuffer(arrayBuffer) {
                var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
                new Uint8Array(result).set(new Uint8Array(arrayBuffer));
                return result;
              }
              function cloneTypedArray(typedArray, isDeep) {
                var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
                return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
              }
              function copyArray(source, array) {
                var index = -1,
                  length = source.length;

                array || (array = Array(length));
                while (++index < length) {
                  array[index] = source[index];
                }
                return array;
              }
              function copyObject(source, props, object, customizer) {
                var isNew = !object;
                object || (object = {});

                var index = -1,
                  length = props.length;

                while (++index < length) {
                  var key = props[index];

                  var newValue = customizer ? customizer(object[key], source[key], key, object, source) : undefined;

                  if (newValue === undefined) {
                    newValue = source[key];
                  }
                  if (isNew) {
                    baseAssignValue(object, key, newValue);
                  } else {
                    assignValue(object, key, newValue);
                  }
                }
                return object;
              }
              function createAssigner(assigner) {
                return baseRest(function (object, sources) {
                  var index = -1,
                    length = sources.length,
                    customizer = length > 1 ? sources[length - 1] : undefined,
                    guard = length > 2 ? sources[2] : undefined;

                  customizer =
                    assigner.length > 3 && typeof customizer == 'function' ? (length--, customizer) : undefined;

                  if (guard && isIterateeCall(sources[0], sources[1], guard)) {
                    customizer = length < 3 ? undefined : customizer;
                    length = 1;
                  }
                  object = Object(object);
                  while (++index < length) {
                    var source = sources[index];
                    if (source) {
                      assigner(object, source, index, customizer);
                    }
                  }
                  return object;
                });
              }
              function createBaseFor(fromRight) {
                return function (object, iteratee, keysFunc) {
                  var index = -1,
                    iterable = Object(object),
                    props = keysFunc(object),
                    length = props.length;

                  while (length--) {
                    var key = props[fromRight ? length : ++index];
                    if (iteratee(iterable[key], key, iterable) === false) {
                      break;
                    }
                  }
                  return object;
                };
              }
              function getMapData(map, key) {
                var data = map.__data__;
                return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;
              }
              function getNative(object, key) {
                var value = getValue(object, key);
                return baseIsNative(value) ? value : undefined;
              }
              function getRawTag(value) {
                var isOwn = hasOwnProperty.call(value, symToStringTag),
                  tag = value[symToStringTag];

                try {
                  value[symToStringTag] = undefined;
                  var unmasked = true;
                } catch (e) {}

                var result = nativeObjectToString.call(value);
                if (unmasked) {
                  if (isOwn) {
                    value[symToStringTag] = tag;
                  } else {
                    delete value[symToStringTag];
                  }
                }
                return result;
              }
              function initCloneObject(object) {
                return typeof object.constructor == 'function' && !isPrototype(object)
                  ? baseCreate(getPrototype(object))
                  : {};
              }
              function isIndex(value, length) {
                var type = typeof value;
                length = length == null ? MAX_SAFE_INTEGER : length;

                return (
                  !!length &&
                  (type == 'number' || (type != 'symbol' && reIsUint.test(value))) &&
                  value > -1 &&
                  value % 1 == 0 &&
                  value < length
                );
              }
              function isIterateeCall(value, index, object) {
                if (!isObject(object)) {
                  return false;
                }
                var type = typeof index;
                if (
                  type == 'number'
                    ? isArrayLike(object) && isIndex(index, object.length)
                    : type == 'string' && index in object
                ) {
                  return eq(object[index], value);
                }
                return false;
              }
              function isKeyable(value) {
                var type = typeof value;
                return type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean'
                  ? value !== '__proto__'
                  : value === null;
              }
              function isMasked(func) {
                return !!maskSrcKey && maskSrcKey in func;
              }
              function isPrototype(value) {
                var Ctor = value && value.constructor,
                  proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;

                return value === proto;
              }
              function nativeKeysIn(object) {
                var result = [];
                if (object != null) {
                  for (var key in Object(object)) {
                    result.push(key);
                  }
                }
                return result;
              }
              function objectToString(value) {
                return nativeObjectToString.call(value);
              }
              function overRest(func, start, transform) {
                start = nativeMax(start === undefined ? func.length - 1 : start, 0);
                return function () {
                  var args = arguments,
                    index = -1,
                    length = nativeMax(args.length - start, 0),
                    array = Array(length);

                  while (++index < length) {
                    array[index] = args[start + index];
                  }
                  index = -1;
                  var otherArgs = Array(start + 1);
                  while (++index < start) {
                    otherArgs[index] = args[index];
                  }
                  otherArgs[start] = transform(array);
                  return apply(func, this, otherArgs);
                };
              }
              var setToString = shortOut(baseSetToString);
              function shortOut(func) {
                var count = 0,
                  lastCalled = 0;

                return function () {
                  var stamp = nativeNow(),
                    remaining = HOT_SPAN - (stamp - lastCalled);

                  lastCalled = stamp;
                  if (remaining > 0) {
                    if (++count >= HOT_COUNT) {
                      return arguments[0];
                    }
                  } else {
                    count = 0;
                  }
                  return func.apply(undefined, arguments);
                };
              }
              function toSource(func) {
                if (func != null) {
                  try {
                    return funcToString.call(func);
                  } catch (e) {}
                  try {
                    return func + '';
                  } catch (e) {}
                }
                return '';
              }
              function eq(value, other) {
                return value === other || (value !== value && other !== other);
              }
              var isArguments = baseIsArguments(
                (function () {
                  return arguments;
                })(),
              )
                ? baseIsArguments
                : function (value) {
                    return (
                      isObjectLike(value) &&
                      hasOwnProperty.call(value, 'callee') &&
                      !propertyIsEnumerable.call(value, 'callee')
                    );
                  };
              var isArray = Array.isArray;
              function isArrayLike(value) {
                return value != null && isLength(value.length) && !isFunction(value);
              }
              function isArrayLikeObject(value) {
                return isObjectLike(value) && isArrayLike(value);
              }
              var isBuffer = nativeIsBuffer || stubFalse;
              function isFunction(value) {
                if (!isObject(value)) {
                  return false;
                }
                var tag = baseGetTag(value);
                return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
              }
              function isLength(value) {
                return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
              }
              function isObject(value) {
                var type = typeof value;
                return value != null && (type == 'object' || type == 'function');
              }
              function isObjectLike(value) {
                return value != null && typeof value == 'object';
              }
              function isPlainObject(value) {
                if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
                  return false;
                }
                var proto = getPrototype(value);
                if (proto === null) {
                  return true;
                }
                var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
                return typeof Ctor == 'function' && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
              }
              var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
              function toPlainObject(value) {
                return copyObject(value, keysIn(value));
              }
              function keysIn(object) {
                return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
              }
              var merge = createAssigner(function (object, source, srcIndex) {
                baseMerge(object, source, srcIndex);
              });
              function constant(value) {
                return function () {
                  return value;
                };
              }
              function identity(value) {
                return value;
              }
              function stubFalse() {
                return false;
              }

              module.exports = merge;
            }.call(
              this,
              typeof global !== 'undefined'
                ? global
                : typeof self !== 'undefined'
                ? self
                : typeof window !== 'undefined'
                ? window
                : {},
            ));
          },
          {},
        ],
      },
      {},
      [2],
    )(2);
  });
});

ace.define('ace/mode/yaml_worker', [], function (require, exports) {
  'use strict';

  var oop = require('../lib/oop');
  var Mirror = require('../worker/mirror').Mirror;
  var lint = require('./yaml/yaml-lint').lint;

  var YamlWorker = (exports.YamlWorker = function (sender) {
    Mirror.call(this, sender);
    this.setTimeout(500);
    this.setOptions();
  });

  oop.inherits(YamlWorker, Mirror);

  (function () {
    this.setOptions = function () {
      this.doc.getValue() && this.deferredUpdate.schedule(100);
    };

    this.changeOptions = function (newOptions) {
      oop.mixin(this.options, newOptions);
      this.doc.getValue() && this.deferredUpdate.schedule(100);
    };

    this.onUpdate = function () {
      var _this = this;
      var value = this.doc.getValue();
      var errors = [];

      lint(value, {}, function (error) {
        if (!error) {
          _this.sender.emit('annotate', errors);
          return;
        }

        errors.push({
          row: error.mark.line,
          column: error.mark.column,
          text: error.reason,
          type: 'error',
          raw: error,
        });

        _this.sender.emit('annotate', errors);
      });
    };
  }.call(YamlWorker.prototype));
});
